Using constraint programming to obtain a machine maintenance schedule for maintenance tasks

ABSTRACT

Information about a set of maintenance tasks and time windows includes a cost value per task per time window. Based on the information, a data model generator generates a data model, including task elements; time elements; cost elements; a total cost element; a constraint that requires each task element be assigned a time window from a respective domain, such that each time element is assigned a task count from a respective domain; a constraint that requires each cost element be assigned a cost value associated with a time window assigned (or to be assigned) to a task element corresponding to the cost element; and a constraint that requires the total cost element be assigned a total cost value that is a sum of the cost values assigned (or to be assigned) to the cost elements. Based on the data model, a CP solver determines a proposed maintenance schedule.

INCORPORATION BY REFERENCE; DISCLAIMER

The following applications are hereby incorporated by reference: U.S.Provisional Patent Application No. 62/723,945 filed on Aug. 28, 2018;and U.S. Non-Provisional patent application Ser. No. 16/405,638 filed onMay 7, 2019. The Applicant hereby rescinds any disclaimer of claim scopein the parent applications or the prosecution history thereof andadvises the USPTO that the claims in this application may be broaderthan any claim in the parent applications.

TECHNICAL FIELD

The present disclosure relates to the use of constraint programming. Inparticular, the present disclosure relates to using constraintprogramming to obtain a machine maintenance schedule for maintenancetasks.

BACKGROUND

A machine is a hardware apparatus configured to perform one or morefunctions. Examples of machines include factory machines (such asmanufacturing machines), trucks, and computing devices.

A machine generally needs maintenance service from time to time in orderto maintain the machine's operation and/or efficiency. A machine may beassociated with a default maintenance schedule that is specified by amachine manual and/or a machine manufacturer. However, the actualmaintenance needs of a machine may change depending on various factors,such as actual usage duration, actual production levels, operatingconditions, and/or operating errors.

If a machine is maintained based on a default maintenance schedule,rather than the machine's actual maintenance needs, the machine may failbefore a necessary maintenance task is performed. The machine's failuremay require additional resources to be repaired, thereby resulting inprolonged downtime. Additionally, the machine's failure may be anunexpected interruption of the machine's functions, causing rippleeffects in the production chain.

Moreover, if a machine is maintained based on a default machineschedule, the machine may be serviced even though the machine's risk offailure is very low. Performing unnecessary maintenance results inunnecessary downtime for the machine.

The approaches described in this section are approaches that could bepursued, but not necessarily approaches that have been previouslyconceived or pursued. Therefore, unless otherwise indicated, it shouldnot be assumed that any of the approaches described in this sectionqualify as prior art merely by virtue of their inclusion in thissection.

BRIEF DESCRIPTION OF THE DRAWINGS

The embodiments are illustrated by way of example and not by way oflimitation in the figures of the accompanying drawings. It should benoted that references to “an” or “one” embodiment in this disclosure arenot necessarily to the same embodiment, and they mean at least one. Inthe drawings:

FIGS. 1A-B illustrate a constraint programming data model and searchdirective generation system, in accordance with one or more embodiments;

FIG. 2 illustrates an example set of operations for generating a datapacket including information about a set of maintenance tasks and a setof candidate time windows, in accordance with one or more embodiments;

FIGS. 3A-B illustrate an example set of operations for generating aconstraint programming data model, in accordance with one or moreembodiments;

FIG. 4 illustrates an example set of operations for generating aconstraint programming search directive, in accordance with one or moreembodiments;

FIG. 5 illustrates an example set of operations applying a constraintprogramming data model and search directive to a constraint programmingsolver, in accordance with one or more embodiments;

FIG. 6 illustrates an example set of operations for presenting andexecuting a proposed maintenance schedule, in accordance with one ormore embodiments;

FIG. 7A illustrates an example graphical user interface indicating acurrent maintenance schedule for performing a set of maintenance tasks,in accordance with one or more embodiments;

FIG. 7B illustrates an example graphical user interface overlaying aproposed maintenance schedule, on top of a current maintenance schedule,for performing a set of maintenance tasks, in accordance with one ormore embodiments;

FIG. 8 shows a block diagram that illustrates a computer system inaccordance with one or more embodiments.

DETAILED DESCRIPTION

In the following description, for the purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding. One or more embodiments may be practiced without thesespecific details. Features described in one embodiment may be combinedwith features described in a different embodiment. In some examples,well-known structures and devices are described with reference to ablock diagram form in order to avoid unnecessarily obscuring the presentinvention.

-   -   1. GENERAL OVERVIEW    -   2. CONSTRAINT PROGRAMMING DATA MODEL AND SEARCH DIRECTIVE        GENERATION SYSTEM ARCHITECTURE    -   3. GENERATING A CONSTRAINT PROGRAMMING DATA MODEL AND SEARCH        DIRECTIVE FOR DETERMINING A PROPOSED MAINTENANCE SCHEDULE        -   A. DETERMINING A SET OF MACHINES, MAINTENANCE TASKS,            CANDIDATE TIME WINDOWS, AND RELATED INFORMATION        -   B. DETERMINING A CONSTRAINT PROGRAMMING DATA MODEL        -   C. DETERMINING A CONSTRAINT PROGRAMMING SEARCH DIRECTIVE        -   D. APPLYING A CONSTRAINT PROGRAMMING DATA MODEL AND SEARCH            DIRECTIVE TO A CONSTRAINT PROGRAMMING SOLVER    -   4. GRAPHICAL USER INTERFACE FOR PRESENTING A PROPOSED        MAINTENANCE SCHEDULE    -   5. HARDWARE OVERVIEW    -   6. MISCELLANEOUS; EXTENSIONS

1. General Overview

One or more embodiments include using constraint programming todetermine a proposed maintenance schedule for performing a set ofmaintenance tasks for a set of machines.

Constraint programming (CP) is a form of declarative programming. CPobtains a solution to a real-world problem based on a specification of aCP data model and optionally a CP search directive. In contrast,imperative programming is based on a specification of a sequence ofsteps.

A CP data model includes a set of data model elements; domains ofpossible values that can be assigned to each element; and one or moreconstraints that define combinations of values that are allowed to beassigned to the elements. Based on the CP data model, a set of valuesfor the set of elements that satisfies all constraints is determined. Aset of values for the set of elements that satisfies all constraints maybe referred to herein as a “CP solution.”

A CP search directive guides the assignment of a set of values to a setof data model elements that satisfies all constraints, as specified by aCP data model. The CP search directive prioritizes the assignment ofcertain preferred values over other values for one or more elements.Different CP search directives for a same CP data model may result in adifferent ordering of CP solutions.

One or more embodiments include generating a CP data model, to beapplied to a CP solver, for determining a proposed maintenance schedulefor performing a set of machine maintenance tasks, while satisfying atleast one or more of the following objectives:

-   -   (a) limiting time windows during which each maintenance task may        be performed;    -   (b) limiting a number of maintenance tasks that may be performed        during each time period;    -   (c) minimizing a total cost value for performing the set of        maintenance tasks, wherein the cost value for performing a        particular maintenance task on a particular machine during a        particular task window takes into account various factors such        as (i) a failure probability of the machine, (ii) a production        schedule of the machine, including a quantity of products to be        produced and/or a value of the products, (iii) a time window        currently scheduled for the particular maintenance task,        and (iv) time window restrictions and/or preferences for the        particular maintenance task; and    -   (d) enforcing respective time window restrictions on each        maintenance task.

The CP data model includes at least:

-   -   (a) a set of task elements representing a set of maintenance        tasks;    -   (b) a set of time elements representing a set of time windows;    -   (c) a set of cost elements corresponding to the set of task        elements; and    -   (d) a total cost element.

A domain of a task element indicates candidate time windows forperforming the maintenance task represented by the task element. Adomain of a time element indicates task counts permitted for the timewindow represented by the time element. A domain of a cost element,corresponding to a particular task element, indicates various costvalues for performing the maintenance task represented by the particulartask element during the candidate time windows. A domain of a total costelement indicates possible total cost values for performing the set ofmaintenance tasks.

Further, the CP data model includes at least:

-   -   (a) a global cardinality constraint that requires each task        element to be assigned a time window from the respective domain,        such that each time element is assigned a task count from the        respective domain, wherein a task count for a particular time        element is a number of task elements assigned with a time window        represented by the particular time element;    -   (b) a set of one or more element constraints, wherein an element        constraint requires each cost element be assigned a cost value        associated with performing a corresponding maintenance task        during a time window assigned (or to be assigned) to the        corresponding maintenance task; and    -   (c) a sum constraint that requires the total cost element be        assigned a total cost value equal to a sum of the cost values        assigned (or to be assigned) to the cost elements.

CP is a more efficient way (than imperative programming) for obtaining aproposed maintenance schedule for performing a set of maintenance tasksfor a set of machines, while satisfying one or more of the aboveobjectives. CP is more efficient because, as further described below, aCP data model that includes certain constraints is sufficient forobtaining a proposed maintenance schedule that satisfies multipleobjectives. Even if there are changes to parameters of the problem (suchas the maintenance tasks, time windows, and/or cost values), theconstraints of the CP data model do not necessarily need to be changed.In contrast, using imperative programming to solve the problem withmultiple objectives would involve a large number of steps.

One or more embodiments include iteratively applying a CP data model toa CP solver to obtain a proposed maintenance schedule. A total costvalue associated with a prior solution obtained by the CP solver is usedas an upper bound for the domain of the total cost element in a nextiteration of the CP solver. The iterative process may be interrupted torequest a solution associated with a lowest total cost value thus far.The iterative process may thereafter resume to continue findingsolutions with even lower total cost values. The iterative process iscomplete when the domain of the total cost element is so modified (withthe lowering of the upper bound for the domain of the total costelement) that no valid solution satisfying all constraints exists. Thenthe last-determined solution is the “best” solution associated with thelowest total cost value. A proposed maintenance schedule is determinedbased on the last-determined solution.

By modifying the CP data model based on a lowest total cost value thusfar in each iteration, a set of solutions with total cost values higherthan the lowest total cost value thus far are omitted and neverattempted. The CP solver may thus more efficiently arrive at a solutionwith a lowest total cost value possible. Moreover, by modifying the CPdata model based on a lowest total cost value thus far in eachiteration, a user may interrupt the iterative process at any time torequest the solution with the lowest total cost value thus far. The usermay determine to use the best solution obtained thus far, withoutwaiting for the CP solver to complete the iterative process.

One or more embodiments include determining a cost value per maintenancetask per time window based on machine attributes and/or task attributes.Examples of machine attributes include (a) a failure probability of themachine, and (b) a production schedule of the machine, including aquantity of products to be produced and/or a value of the products.Examples of task attributes include (a) a time window currentlyscheduled for the maintenance task, and (b) time window restrictionsand/or preferences for the maintenance task. The machine attributesand/or task attributes are input into an algorithm that outputs a costvalue per maintenance task per time window. The algorithm may rely onmulti-attribute utility theory.

The choice of using a single cost value that takes into account themultiple machine attributes and/or task attributes allows a user tocustomize preferences for assigning the time windows to the maintenancetasks outside of the CP data model. As an example, if the user desiresto prioritize repairing machines with high probability of failure ratesover minimizing negative impacts caused by repairing to productionschedules, then the user may increase the effect on the cost value dueto the probability of failure and/or decrease the effect on the costvalue due to the interruption of the production schedule.

One or more embodiments include presenting and executing a proposedmaintenance schedule. A graphical user interface (GUI) presents theproposed maintenance schedule to one or more users. A GUI may overlaythe proposed maintenance schedule on top of the current maintenanceschedule. Additionally or alternatively, maintenance resources obtainthe proposed maintenance schedule. The maintenance resources perform themaintenance tasks according to the proposed maintenance schedule. Themaintenance tasks may be performed with or without human intervention.

The above approach improves a CP solver's ability to determine aproposed maintenance schedule for performing a set of maintenance tasksfor a set of machines, while satisfying one or more objectives. Based ona CP data model, as described above, the CP solver may efficientlydetermine a proposed maintenance schedule associated with a lowest totalcost value. Using different CP data models, the CP solver might be ableto determine proposed maintenance schedules, but not one that isassociated with a lowest total cost value. Additionally oralternatively, the CP solver might not be able to efficiently take intoaccount the various machine attributes and/or task attributes whendetermining a solution.

The above approach further improves maintenance of a set of machines,and thereby improves the capability of the machines. Without generatinga proposed maintenance schedule, as described, machines may be servicedbased on default maintenance schedules, without regard to factors thatmay alter a machine's maintenance needs. Additionally or alternatively,machines may be served without regard to a machine's productionschedule. The above-described proposed maintenance schedule decreasesfailure risk while minimizing disruption to production schedules.

The above approach further improves a GUI for presenting maintenanceschedules. Rather than presenting only the current maintenance schedule,or only the proposed maintenance schedule, the GUI concurrently presentsboth the current maintenance schedule and the proposed maintenanceschedule. The GUI overlays the proposed maintenance schedule on thecurrent maintenance schedule. The GUI presents arrows indicatingmodifications from the current maintenance schedule to the proposedmaintenance schedule. Therefore, a user may easily view the schedulemodifications, and implement changes to maintenance resources asnecessary.

One or more embodiments described in this Specification and/or recitedin the claims may not be included in this General Overview section.

2. Constraint Programming Data Model and Search Directive GenerationSystem Architecture

FIG. 1 illustrates a constraint programming data model and searchdirective generation system, in accordance with one or more embodiments.As illustrated in FIG. 1, a system 100 includes a set of machines 102a-b, a set of maintenance tasks 104 a-b, candidate time windows 110, adata packet generator 126, a data model generator 114, a searchdirective generator 116, a constraint programming (CP) solver 132, aproposed maintenance schedule 134, maintenance resources 136, and agraphical user interface (GUI) 138. In one or more embodiments, thesystem 100 may include more or fewer components than the componentsillustrated in FIG. 1. The components illustrated in FIG. 1 may be localto or remote from each other. The components illustrated in FIG. 1 maybe implemented in software and/or hardware. Each component may bedistributed over multiple applications and/or machines. Multiplecomponents may be combined into one application and/or machine.Operations described with respect to one component may instead beperformed by another component.

In one or more embodiments, a machine (such as any of machines 102 a-b)is a hardware apparatus configured to perform one or more functions.Examples of machines include factory machines (such as manufacturingmachines), trucks, and computing devices.

Each machine is associated with one or more machine attributes. Examplesof machine attributes include a failure probability 106 and a productionschedule 107.

A failure probability 106 is a probability that a machine would fail. Amachine that has failed operates below a threshold standard, or iscompletely inoperable. A machine with a greater failure probability mayoperate less efficiently than a machine with a lesser failureprobability. A failure probability may be determined based on variousfactors. As an example, a failure probability may be determined based ondata detected by one or more sensors associated with the machine. Thesensors may be installed inside and/or adjacent to the machines. Thesensors may detect, for example, a temperature and an air pressurewithin the machine. The temperature and air pressure may be input to analgorithm to determine the failure probability. The algorithm may beobtained using machine learning. As another example, a failureprobability may be determined based on factors such as, a frequency,duration, and/or type of usage of the machine. The factors may be inputto an algorithm to determine the failure probability. The algorithm maybe obtained using machine learning

A production schedule 107 indicates a number and type of products that amachine would produce and/or generate during different time periods.Based on a production schedule 107, a value of the products that wouldbe produced during a particular time period may be determined. If themachine needs to be shut down in order to be serviced, then the lostvalue for shutting down the machine would include at least the value ofthe products. The lost value may be used to determine a cost value forservicing the machine during the particular time period (or during atime window including the particular time period).

In one or more embodiments, each machine is associated with one or moremaintenance tasks. A maintenance task (such as any of maintenance tasks104 a-b) is a task for maintaining a machine. Different machines may beassociated with different maintenance tasks. As an example, maintenancetasks for a factory machine may include performing a routine checkup,replacing gears, and changing oil. Maintenance tasks for a truck mayinclude performing a routine checkup, rotating tires, and changing oil.As illustrated, one or more maintenance tasks 104 a are to be performedon machine 102 a; one or more maintenance tasks 104 b are to beperformed on machine 102 b.

Each maintenance task is associated with one or more task attributes.Examples of task attributes include currently-assigned time window 108,and one or more time window restrictions 109.

A currently-assigned time window 108 is a time window scheduled forperforming a maintenance task according to a current maintenanceschedule. A current maintenance schedule may be stored in a datarepository.

A current maintenance schedule may be determined based on a defaultmaintenance schedule. A default maintenance schedule is a maintenanceschedule that is recommended by a machine manual and/or a machinemanufacturer. Additionally or alternatively, a current maintenanceschedule may be determined based on a prior execution of the operationsdescribed herein with reference to FIGS. 2-6. The current maintenanceschedule may be determined based on parameters such as failureprobabilities, production schedules, previously-assigned time windows,time window restrictions, that were used during the prior execution ofthe operations as illustrated in FIGS. 2-6. The set of parameters mayhave been updated or changed since the prior execution of the operationsas illustrated in FIGS. 2-6.

A time window restriction 109 is a restriction on a time window to beassigned to a maintenance task. Different types of time windowrestrictions may be used. As an example, a time window restriction mayrequire that a particular maintenance task not be performed during aparticular subset of the candidate time windows. As another example, atime window restriction may require that a particular maintenance taskmust be performed during a particular subset of the candidate timewindows.

As another example, a time window restriction may require a particularsequence of maintenance tasks. Hence, a time window assigned to aparticular maintenance task must be before a time window assigned toanother maintenance task. As another example, a time window restrictionmay require a particular set of maintenance tasks to be performed in thesame time window. As another example, a time window restriction mayrequire a particular set of maintenance tasks to be performed indifferent time windows.

Another example of a task attribute is an impact of the maintenance taskon an operation of a machine. Performance of a particular task mayrequire that the machine be completely shut down. Performance of anothertask may reduce a machine's productivity to 75% of the normal level.Performance of yet another task may have no impact to the machine'soperation.

In one or more embodiments, candidate time windows 110 are possible timewindows for performing a set of maintenance tasks 104 a-b. The durationof each candidate time window 110 may be any value, such as one day, ortwo hours. The duration of each candidate time window 110 may be same ordifferent.

In one or more embodiments, a data repository (not illustrated) is anytype of storage unit and/or device (e.g., a file system, database,collection of tables, or any other storage mechanism) for storing data.Further, a data repository may include multiple different storage unitsand/or devices. The multiple different storage units and/or devices mayor may not be of the same type or located at the same physical site. Adata packet generator 126, data model generator 114, and/or searchdirective generator 116 may share a single data repository, or may useseparate data repositories. Further, a data repository may beimplemented or may execute on the same computing system as a data packetgenerator 126, data model generator 114, and/or search directivegenerator 116. Alternatively or additionally, a data repository 118 maybe implemented or executed on a computing system separate from a datapacket generator 126, data model generator 114, and/or search directivegenerator 116. The data repository 118 may be communicatively coupled tothe data packet generator 126, data model generator 114, and/or searchdirective generator 116 via a direct connection or via a network. A datapacket 128, data model 120, and/or search directive 125 may be stored onone or more data repositories.

In one or more embodiments, a data packet 128 includes a set ofinformation about a set of maintenance tasks 104 a-b and candidate timewindows 110. A data packet 128 may be used in generating a data model120 and/or a search directive 125. In particular, a data packet 128includes cost values for performing each maintenance task 104 a-b foreach candidate time window 110. A cost value for performing a particularmaintenance task may be different for different time windows. As anexample, candidate time windows for performing a set of tasks mayinclude W₁, W₂, W₃, W₄. Possible time windows for performing a firsttask T₁ may be W₁, W₂, and W₄. Possible time windows for performing asecond task T₂ may be W₁ and W₃. A data packet associated with the tasksmay include a set of cost values. A first subset of the cost valuescorrespond to T₁: C₁₁ is a cost value for performing T₁ during W₁; C₁₂is a cost value for performing T₁ during W₂; and C₁₄ is a cost value forperforming T₁ during W₄. A second subset of the cost values correspondto T₂: C₂₁ is a cost value for performing T₂ during W₁; and C₂₃ is acost value for performing T₂ during W₃. The data packet does notnecessarily include any cost value for performing T₁ during W₃, since W₃is not a possible time window for T₁. The data packet does notnecessarily include any cost value for performing T₂ during W₂ or W₄,since W₂ and W₄ are not possible time windows for T₂.

In one or more embodiments, a data model 120 (also referred to as a “CPdata model”) refers to a particular organization, structure, and/orrepresentation of information about a set of maintenance tasks 104 a-band candidate time windows 110. A CP data model 120 may be implementedas a software data structure readable by one or more devices includingrespective hardware processors. A CP data model 120 may include a set ofinstructions executable by one or more devices including respectivehardware processors. A CP data model 120 may serve as an input parameterinto a hardware and/or software component, such as a CP solver 132.

Referring to FIG. 1B, a data model 120 includes a set of data modelelements 122. Each data model element is associated with a domain ofpossible values that can be assigned to the data model element. A datamodel element cannot be assigned a value that is not within the domainof the data model element. A data model element may be implemented as anarray, a vector, a linked list, a table, a software variable, aconstant, and/or other software data structures or data objects.

In an embodiment, data model elements 122 in a data model 120 include atleast:

-   -   (a) a set of task elements representing a set of maintenance        tasks;    -   (b) a set of time elements representing a set of time windows;    -   (c) a set of cost elements corresponding to the set of task        elements; and    -   (d) a total cost element.

A domain of a task element indicates candidate time windows forperforming the maintenance task represented by the task element. Adomain of a time element indicates task counts permitted for the timewindow represented by the time element. A domain of a cost element,corresponding to a particular task element, indicates various costvalues for performing the maintenance task represented by the particulartask element during the candidate time windows. A domain of a total costelement indicates possible total cost values for performing the set ofmaintenance tasks.

As an example, a set of maintenance tasks may include a maintenance taskfor Canning Machine and a maintenance task for Sealing Machine. A set ofcandidate time windows may include a 7-day time period (Sunday toSaturday). Server C may be configured to perform the maintenance taskfor Canning Machine but not the maintenance task for Sealing Machine.Server S may be configured to perform the maintenance task for SealingMachine but not the maintenance task for Canning Machine. Server C maybe loaned to a different user on Friday and therefore unavailable forperforming any maintenance tasks on Friday. Meanwhile, Server S may beavailable all 7 days.

A set of task elements may be expressed as a vector M[i]. M[0] mayrepresent the maintenance task for Canning Machine. M[1] may representthe maintenance task for Sealing Machine. A domain of M[0] may indicatepossible time windows for servicing Canning Machine, that is, Sunday,Monday, Tuesday, Wednesday, Thursday, and Saturday. A domain of M[1] mayindicate possible time windows for servicing Sealing Machine, that is,Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, and Saturday.Hence, the respective domains of the task elements may be expressed asfollows:

M[0]: {0, 1, 2, 3, 4, 6};

M[1]: {0, 1, 2, 3, 4, 5, 6};

wherein the values 0-6 within the domains represent the time windows,Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, and Saturday,respectively.

As another example, a set of time windows may include 8 am-10 am, 10am-12 pm, and 2 pm-4 pm. Due to limited resources, during 8 am-10 am, amaximum of 4 maintenance tasks may be performed. During 10 am-12 pm, amaximum of 6 maintenance tasks may be performed. During 2 pm-4 pm, amaximum of 5 maintenance tasks may be performed.

A set of time elements may be expressed as a vector T[i]. T[0] mayrepresent the time window 8 am-10 am. T[1] may represent the time window10 am-12 pm. T[2] may represent the time window 2 pm-4 pm. Hence, therespective domains of the time elements may be expressed as follows:

T[0]: {0, 1, 2, 3, 4};

T[1]: {0, 1, 2, 3, 4, 5, 6};

T[2]: {0, 1, 2, 3, 4, 5};

wherein the values 0-6, within the domains, represent task counts duringa time window.

As another example, cost values for performing a first maintenance taskmay be 100 for a first time window, 200 for a second time window, and300 for a third time window. Cost values for performing a secondmaintenance task may be 150 for a first time window, 180 for a secondtime window, and 150 for a third time window.

A set of cost elements may be expressed as a vector C[i]. C[0] maycorrespond to the first maintenance task. C[1] may correspond to thesecond maintenance task. Hence, the respective domains of the costelements may be expressed as follows:

C[0]: {100, 200, 300};

C[1]: {150, 180};

wherein the values 100, 150, 180, 200, 300, within the domains,represent possible cost values for performing the maintenance tasks.

A total cost element may be expressed as a variable TC. Possible totalcost values are determined based on possible assignments of time windowsto maintenance tasks. For example, if the first maintenance task isassigned to the first time window and the second maintenance task isassigned to the first time window, then the total cost value is a sum of100 (for the first maintenance task) and 150 (for the second maintenancetask), which is 250. If the first maintenance task is assigned to thesecond time window and the second maintenance task is assigned to thefirst time window, then the total cost value is a sum of 200 (for thefirst maintenance task) and 150 (for the second maintenance task), whichis 350. Hence, the domain of the total cost element may be expressed asfollows:

TC: {250, 280, 350, 380, 450, 480};

wherein the values 250, 280, 350, 380, 450, 480, within the domain,represent possible total cost values for performing the maintenancetasks.

In an embodiment, a data model 120 accounts for a scenario where thenumber of maintenance tasks to be performed is greater than a number oftime slots provided by the candidate time windows 110. A set of timeelements in the data model 120 includes (a) a set of actual timeelements, corresponding to the candidate time windows 110, and (b) anoverflow time element representing an overflow time window. A domain ofthe overflow time element includes the range of numbers from 0 to thenumber of maintenance tasks to be performed. Each task element in thedata model 120 has a domain that includes the overflow time window. Eachcost element in the data model 120 has a domain that includes anoverflow cost value associated with the overflow time window. Theoverflow cost value is greater than each cost value for actuallyperforming a maintenance task during a candidate time window. Based onthe data model 120, a task element that is assigned the overflow timewindow indicates that the maintenance task represented by the taskelement is not scheduled for actual performance. Moreover, since theoverflow cost value is greater than actual cost values, when anobjective of the CP solver is to minimize a total cost value, assignmentof the overflow time window occurs only when assignment of any candidatetime windows is not possible.

Referring still to FIG. 1B, a data model 120 includes a set ofconstraints 124, including a hard constraints 124 a and a softconstraint 124 b. A hard constraint 124 a defines combinations of valuesthat are allowed to be assigned to a set of data model elements 122(such as task elements and time elements described above). A softconstraint 124 b specifies a preference for certain one or more valuesto be assigned to one or more data model elements 122.

In an embodiment, hard constraints 124 a in a data model 120 include atleast:

-   -   (a) a global cardinality constraint (GCC) that requires each        task element to be assigned a time window from the respective        domain, such that each time element is assigned a task count        from the respective domain, wherein a task count for a        particular time element is a number of task elements assigned        with a time window represented by the particular time element;    -   (b) an element constraint that requires each cost element be        assigned a cost value associated with performing a corresponding        maintenance task during a time window assigned (or to be        assigned) to the corresponding maintenance task; and    -   (c) a sum constraint that requires the total cost element be        assigned a total cost value equal to a sum of the cost values        assigned (or to be assigned) to the cost elements.

In an embodiment, a GCC accepts three parameters: (a) a set of datamodel elements,

-   -   (b) a set of values that may be assigned to the data model        elements, and (c) a set of counting elements for counting a        number of times that each value has been assigned.

A set of data model elements input to a GCC needs to be assigned a valuefrom a respective domain.

As an example, a set of data model elements input to a GCC may be thetask elements:

M[0]: {0, 1, 2, 3, 4, 6};

M[1]: {0, 1, 2, 3, 4, 5, 6}.

Hence, M[0] needs to be assigned value from {0, 1, 2, 3, 4, 6}. M[1]needs to be assigned value from {0, 1, 2, 3, 4, 5, 6}.

A set of values input to a GCC include any value that may be assigned toany of the set of data model elements input to the GCC.

Referring to the example above, a set of data model elements input to aGCC may be the task elements:

M[0]: {0, 1, 2, 3, 4, 6};

M[1]: {0, 1, 2, 3, 4, 5, 6}.

A set of values input to the GCC may include: {0, 1, 2, 3, 4, 5, 6}.

Hence, the set of values includes any value that may be assigned to anyof the data model elements, {0, 1, 2, 3, 4, 5, 6).

A set of counting elements input to a GCC is a set of counterscorresponding to a set of values input to the GCC. Each counter counts anumber of times that the corresponding value is assigned to any of a setof data model elements.

Referring to the example above, a set of data model elements input to aGCC may be the task elements:

M[0]: {0, 1, 2, 3, 4, 6};

M[1]: {0, 1, 2, 3, 4, 5, 6}.

A set of values input to the GCC may include 10, 1, 2, 3, 4, 5, 6}.

A set of counting elements input to the GCC may be:

T[0]: {0, 1, 2};

T[1]: {0, 1};

T[2]: {0, 1, 2, 3};

T[3]: {0, 1, 2, 3, 4, 5};

T[4]: {0, 1, 2, 3, 4};

T[5]: {0, 1, 2};

T[6]: {0}.

Hence, T[0] represents a number of times that the value 0 may beassigned. T[1] represents a number of times that the value 1 may beassigned. T[2] represents a number of times that the value 2 may beassigned. T[3] represents a number of times that the value 3 may beassigned. T[4] represents a number of times that the value 4 may beassigned. T[5] represents a number of times that the value 5 may beassigned. T[6] represents a number of times that the value 6 may beassigned.

Further, a domain of T[0] indicates that the value 0 may be assigned (toany data model element) a maximum of 2 times. A domain of T[1] indicatesthat the value 1 may be assigned (to any data model element) a maximumof 1 time. A domain of T[2] indicates that the value 2 may be assigned(to any data model element) a maximum of 3 times. A domain of T[3]indicates that the value 3 may be assigned (to any data model element) amaximum of 5 times. A domain of T[4] indicates that the value 4 may beassigned (to any data model element) a maximum of 4 times. A domain ofT[5] indicates that the value 5 may be assigned (to any data modelelement) a maximum of 2 times. A domain of T[6] indicates that the value6 may be assigned a maximum of 0 times (which means, the value 6 cannotbe assigned to any data model element at all).

Based on a GCC, a CP solver 132 determines a CP solution wherein eachdata model element is assigned a value from the respective domain, suchthat each counting element is assigned a value from the respectivedomain. Hence, each data model element is assigned a value from therespective domain, while the number of times that each value is assignedis restricted by the domains of the counting elements.

In an embodiment, an element constraint accepts two parameters: (a) aninput data model element, and (b) a particular sequence of values. Theelement constraint outputs to an output data model element.

An output data model element needs to be assigned a value from thedomain of the output data model element.

As an example, an output data model element may be the cost element,C[0]: {100, 200, 300}.

Hence, C[0] needs to be assigned value from {100, 200, 300}.

An input data model element input to an element constraint serves toindex into a particular sequence of values input to the elementconstraint. The element constraint returns a particular value from theparticular sequence of values that maps to a value assigned (orto-be-assigned) to the input data model.

As an example, an output data model element may be the cost element asdescribed above, C[0]: {100, 200, 300}.

An input data model element may be the task element, M[0]: {0, 1, 2}. Aparticular sequence of values may be 1300, 100, 2001. The particularsequence of values may indicate cost values for performing a maintenancetask represented by M[0] for each candidate time window.

Based on the element constraint, a value of 0 assigned to M[0] maps to300 of the particular sequence of values; and hence a value of 300 isreturned. A value of 1 assigned to M[0] maps to 100 of the particularsequence of values; and hence a value of 100 is returned. A value of 2assigned to M[0] maps to 200 of the particular sequence of values; andhence a value of 200 is returned. A CP solver 132 determines a CPsolution wherein a value returned from the element constraint is withinthe domain of the cost element.

In an embodiment, a sum constraint accepts as a parameter a set of inputdata model elements. The sum constraint outputs to an output data modelelement.

An output data model element needs to be assigned a value from thedomain of the output data model element.

As an example, an output data model element may be the total costelement, TC: {150, 250, 280, 350, 380, 450, 480}.

Hence, TC needs to be assigned value from {150, 250, 280, 350, 380, 450,480}.

The sum constraint returns a sum of values assigned (and/orto-be-assigned) to a set of input data model elements.

Referring to the example above, an output data model element may be thetotal cost element, TC: {150, 250, 280, 350, 380, 450, 480}.

A set of input data model elements may be a set of cost elements, eachcorresponding to a respective task element. The cost elements may be:

C[0]: {100, 200, 300, 400}

C[1]: {50, 150, 180}

Based on the sum element, a sum of the values assigned (and/orto-be-assigned) to the set of cost elements is returned. A CP solver 132determines a CP solution wherein a sum returned from the sum constraintis within the domain of the total cost element.

In this example, certain assignments would result in a sum returned fromthe sum constraint being outside of the domain of the total costelement. For example, if 400 is assigned to C[0] and 150 is assigned toC[1], then the sum would be 550. However, 550 is outside of the domainof the total cost element. Hence, the sum constraint is not satisfied.Any CP solution returned by the CP solver 132 would not include such anassignment.

In an embodiment, hard constraints 124 a may also include a constraintbased on a time window restriction. As an example, a constraint mayspecify that time windows assigned to certain task elements be the same.Another constraint may specify that time windows assigned to certainother task elements be different. Another constraint may specify that atime window assigned to a particular task element must be before a timewindow assigned to another particular task element.

Referring back to FIG. 1A, in one or more embodiments, a searchdirective 125 is a directive that guides a CP solver 132 in the processof determining a CP solution given a particular data model 120. A searchdirective 125 guides the assignment of a set of values to a set of datamodel elements that satisfies all constraints, as specified by a datamodel 120. A search directive 125 prioritizes the assignment of certainvalues over other values for one or more data model elements. Differentsearch directives 124 for a same data model 120 may result in adifferent ordering of CP solutions, and/or a different approach forarriving at a same CP solution(s). A search directive 125 may beimplemented as a software data structure. A search directive 125 mayinclude a set of computer-readable instructions. A search directive 125may serve as an input parameter into a hardware and/or softwarecomponent, such as a CP solver 132.

In one or more embodiments, a data packet generator 126 refers tohardware and/or software configured to generate a data packet 128 forgenerating a data model 120 and/or a search directive 125. Examples ofoperations for generating a data packet 128 are described below withreference to FIG. 2.

In one or more embodiments, a data model generator 114 refers tohardware and/or software configured to generate a data model 120.Examples of operations for generating a data model 120 are describedbelow with reference to FIGS. 3A-B.

In one or more embodiments, a search directive generator 116 refers tohardware and/or software configured to generate a search directive 125.Examples of operations for generating a search directive 125 aredescribed below with reference to FIG. 4.

In one or more embodiments, a CP solver 132 refers to hardware and/orsoftware configured to determine a CP solution, given a data model 120and optionally a search directive 125, using constraint programmingtechniques. Constraint programming techniques include, for example,backtracking algorithms and forward-checking algorithms.

In one or more embodiments, a data packet generator 126, data modelgenerator 114, search directive generator 116, and/or CP solver 132 isimplemented on one or more digital devices. The term “digital device”generally refers to any hardware device that includes a processor. Adigital device may refer to a physical device executing an applicationor a virtual machine. Examples of digital devices include a computer, atablet, a laptop, a desktop, a netbook, a server, a web server, anetwork policy server, a proxy server, a generic machine, afunction-specific hardware device, a mainframe, a television, a contentreceiver, a set-top box, a printer, a mobile handset, a smartphone,and/or a personal digital assistant (PDA).

In one or more embodiments, a proposed maintenance schedule 134 is aschedule for performing one or more maintenance tasks 104 a-b based on aCP solution determined by a CP solver 132. The CP solution is determinedbased on a data model 120 and optionally a search directive 125. Aproposed maintenance schedule 134 may be a revision from a currentmaintenance schedules for the set of maintenance tasks 104 a-b.

In one or more embodiments, maintenance resources 136 refers to hardwareand/or software configured to perform one or more operations ofmaintenance tasks 104 a-b for a set of machines 102 a-b. Additionally oralternatively, maintenance resources 136 refers to human resourcesskilled to perform one or more operations of maintenance tasks 104 a-bfor a set of machines 102 a-b. Different maintenance resources 136 maybe required for different maintenance tasks 104 a-b. As an example, amaintenance task may be an oil change. Maintenance resources for themaintenance task may include an oil changing machine, new oil, and aworker skilled to operate the oil changing machine. As another example,a maintenance task may be a software update. Maintenance resources forthe maintenance task may include a server configured to perform thesoftware update. As another example, a maintenance task may be garbagecollection for an application. Maintenance resources for the maintenancetask may include a garbage collector configured to perform garbagecollection on a memory associated with the application.

In some embodiments, maintenance resources 136 includes only machines,computing devices, and/or tools, without any human intervention.Performance of a maintenance task is hence fully automated. In someembodiments, maintenance resources 136 may include workers withparticular skills, such as workers capable of operating an oil changingmachine, or workers capable of operating a computer server.

In one or more embodiments, a GUI 138 refers to hardware and/or softwareconfigured to facilitate communications between (a) a user and (b) a CPsolver 132. A GUI 138 may be rendered and/or displayed on a screenand/or monitor. A GUI 138 may present one or more interface elements forpresenting information to a user and/or for receiving information from auser. Examples of interface elements include checkboxes, radio buttons,dropdown lists, list boxes, buttons, toggles, text fields, date and timeselectors, command lines, sliders, pages, and/or forms. Other types ofuser interfaces include a command line interface (CLI), a hapticinterface, and a voice command interface.

Components of a GUI 138 may be specified in one or more languages, suchas Java, C, and/or C++. In some embodiments, the behavior of interfaceelements is specified in a dynamic programming language, such asJavaScript. The content of interface elements is specified in a markuplanguage, such as hypertext markup language (HTML) or XML User InterfaceLanguage (XUL). The layout of interface elements is specified in a stylesheet language, such as Cascading Style Sheets (CSS).

In an embodiment, a GUI 138 presents a proposed maintenance schedule 134overlaid on top of one or more current maintenance schedules 110 a-b.The proposed maintenance schedule 134 and the current maintenanceschedules 110 a-b may be associated with different visualizations, suchas colors, shapes, and/or animations. A GUI 138 presents an interfaceelement configured to receive user input accepting, rejecting, and/orfurther modifying a proposed maintenance schedule 134.

3. Generating a Constraint Programming Data Model and Search Directivefor Obtaining a Proposed Maintenance Schedule

One or more operations illustrated in FIGS. 2-6 may be modified,rearranged, and/or omitted all together. Accordingly, the particularsequence of operations illustrated in FIGS. 2-6 should not be construedas limiting the scope of one or more embodiments.

A. Determining a Set of Machines, Maintenance Tasks, and RelatedInformation

FIG. 2 illustrates an example set of operations for generating a datapacket including information about a set of maintenance tasks and a setof candidate time windows, in accordance with one or more embodiments.

One or more embodiments include identifying a set of machines that needto be maintained (Operation 202). A data packet generator 126 obtainsidentities of a set of machines that need to be maintained from a datarepository. As an example, a set of machines that need to be maintainedmay be factory machines in a factory. A data model generator may obtainidentities of the factory machines from a machine database. As anotherexample, a set of machines that need to be maintained may be trucks of adelivery company. A data model generator may obtain identities of thetrucks from a truck database. As another example, a set of machines thatneed to be maintained may be cloud servers in a cloud network. A datamodel generator may obtain identities of the cloud servers from a masterserver.

One or more embodiments include identifying a set of maintenance tasksto be performed for the set of machines (Operation 204). The data packetgenerator 126 obtains a set of maintenance tasks to be performed for theset of machines from a data repository. The data packet generator 126may obtain identities of one or more maintenance tasks (such as, a taskidentifier (ID) corresponding to each maintenance task). Additionally oralternatively, the data packet generator 126 may obtain instructions,which when executed by at least one device including a hardwareprocessor, performs one or more maintenance tasks.

The data packet generator 126 may obtain one or more maintenance tasksto performed on a particular machine. As an example, a set of machinesto be maintained may include Garment Machine and Ironing Machine. A datapacket generator may determine that Garment Machine requires twomaintenance tasks: replacing gears, and cleaning crevices. The datapacket generator may determine that Ironing Machine requires onemaintenance task: replacing metal plates.

One or more embodiments include identifying a set of candidate timewindows for performing the set of maintenance tasks (Operation 206). Thedata packet generator 126 obtains a set of candidate time windows forperforming the set of maintenance tasks from a data repository. The setof candidate time windows may be specified by a user. Additionally oralternatively, the set of candidate time windows may be determined by anapplication. The set of candidate time windows for performing the set ofmaintenance tasks may be determined based on availability of maintenanceresources. The duration of each candidate time window may be the same ordifferent.

The data packet generator determines possible time windows forperforming each maintenance task. The possible time windows for amaintenance task may be specified by a user. Additionally oralternatively, the possible time windows for a maintenance task may bedetermined by an application. The possible time windows for amaintenance task may be expressed as a time window restriction. As anexample, a time window restriction may indicate that a particularmaintenance task may be performed during only a subset of a set ofcandidate time windows. Hence, the subset of candidate time windows arethe possible time windows for the particular maintenance task.

Possible time windows for performing each maintenance task may be thesame or different. As an example, a data packet generator may determinethat possible time windows for performing a software update maintenancetask include: Monday, Tuesday, and Wednesday. The data packet generatormay further determine that possible time windows for performing agarbage collection maintenance task include: Thursday, and Friday. Asanother example, a data packet generator may determine that possibletime windows for an oil change task are: 10 am-11 am, and 12 pm-1 pm, ona daily basis. The data model generator may further determine thatpossible time windows for a tire rotation task are: 12 pm-2 pm, and 3pm-4 pm, on a daily basis.

One or more embodiments include identifying respective maximum taskcounts for the candidate time windows (Operation 208). The data packetgenerator 126 obtains respective maximum task counts for the candidatetime windows from a data repository. The maximum task counts for thecandidate time windows may be the same or different.

One or more embodiments include identifying a set of machine attributesand/or task attributes (Operation 210). The data packet generator 126identifies a set of machine attributes and/or task attributes.

In an embodiment, the data packet generator 126 obtains a set of failureprobabilities corresponding to the set of machines from a datarepository. The set of failure probabilities may be specified by a user.Additionally or alternatively, the set of failure probabilities may bedetermined by an application. The set of failure probabilities may bedetermined based on various factors, such as data detected by one ormore sensors associated with one or more machines, usage frequencies ofthe machines, usage durations of the machines, and/or types of usage ofthe machines.

As an example, a set of machines may include factory machines. A sensorassociated with a particular factory machine may detect an internaltemperature of the particular factory machine. A failure probability ofthe particular factory machine may be determined based on the internaltemperature. As another example, a set of machine may include a fleet oftrucks. A sensor associated with a particular truck may detect a numberof miles traveled by the truck. A failure probability of the particulartruck may be determined based on the mileage on the truck.

In an embodiment, the data packet generator 126 obtains a set ofproduction schedules corresponding to the set of machines from a datarepository. A production schedule may indicate that different quantitiesof different products are produced and/or generated by a particularmachine at different times.

In an embodiment, the data packet generator 126 obtains a currentmaintenance schedule for the set of maintenance tasks from a datarepository. The current maintenance schedule may be specified by a user.Additionally or alternatively, the current maintenance schedule may bedetermined by an application. The current maintenance schedule may bedetermined based on various factors, such as a recommended serviceinterval, and a maintenance schedule previously determined by a CPsolver. The current maintenance schedule indicates a currently-assignedtime window for each maintenance task.

In an embodiment, the data packet generator 126 obtains one or more timewindow restrictions for the set of maintenance tasks from a datarepository. Different time window restrictions may be associated withdifferent maintenance tasks.

In an embodiment, the data packet generator 126 obtains respectiveimpacts of the maintenance tasks on an operation of a correspondingmachine from a data repository. Different maintenance tasks may beassociated with different impacts. The impact of a particularmaintenance task on an operation of a machine may be specified by auser. Additionally or alternatively, the impact of a particularmaintenance task on an operation of a machine may be determined by anapplication. As an example, an application may monitor historical dataindicating impacts from previous executions of a maintenance task. Theapplication may determine and/or predict an impact of the maintenancetask based on the prior impacts.

One or more embodiments include determining a cost value per time windowper maintenance task based on the machine attributes and/or taskattributes (Operation 212). The data packet generator 126 identifies asubset of machine attributes and/or task attributes relevant to eachcost value. For a particular cost value associated with performing aparticular maintenance task on a particular machine during a particulartime window, the relevant attributes include the machine attributes ofthe particular machine during the particular time window. The relevantattributes also include the task attributes of the particularmaintenance task during the particular time window.

The data packet generator 126 determines an effect on each cost valuedue to each attribute relevant to the cost value. Various methods may beused for determining an effect on a cost value due to an attribute,examples of which are described below.

In an embodiment, the data packet generator 126 determines an effect ona particular cost value for performing a particular maintenance task ona particular machine during a particular time window due to a particularfailure probability of the particular machine. In an embodiment, thedata packet generator 126 determines a set of failure probabilities ofthe set of machines being maintained. The data packet generator 126normalizes and/or ranks the particular failure probability based on theset of failure probabilities. The normalized result and/or ranking isthe effect on the particular cost value due to the particular failureprobability. In another embodiment, the data packet generator 126 simplytakes the failure probability itself as the effect on the particularcost value due to the particular failure probability. Hence, a greaterfailure probability results in a greater effect on a cost value.Further, an effect on each cost value for performing a particularmaintenance task on a particular machine for each different time windowdue to a failure probability of the particular machine may be the same.

In an embodiment, the data packet generator 126 determines an effect ona particular cost value for performing a particular maintenance task ona particular machine during a particular time window due to acurrently-assigned time window for the particular maintenance task. Thedata packet generator 126 obtains a current maintenance schedule from adata repository. The data packet generator 126 determines acurrently-assigned time window for the particular maintenance taskaccording to the current maintenance schedule. The data packet generator126 determines a difference between the particular time window and thecurrently-assigned time window. The difference is the effect on theparticular cost value due to the currently-assigned time window. Hence,a greater difference results in a greater effect on a cost value.Determining an effect on a cost factor due to a currently-assigned timewindow is one way of indicating a preference for the currently-assignedwindow in a CP data model.

In an embodiment, the data packet generator 126 determines an effect ona particular cost value for performing a particular maintenance task ona particular machine during a particular time window due to a timewindow restriction for the particular maintenance task. The data packetgenerator 126 determines that a time window restriction indicates apreference for a certain preferred time window to be assigned to theparticular maintenance task. The data packet generator 126 determines adifference between the particular time window and the preferred timewindow. The difference is the effect on the particular cost value due tothe time window restriction. Hence, a greater difference results in agreater effect on a cost value. Determining an effect on a cost factordue to a preferred time window is one way of indicating the preferencein a CP data model.

In an embodiment, the data packet generator 126 determines an effect ona particular cost value for performing a particular maintenance task ona particular machine during a particular time window due to a particularproduction schedule of the particular machine and/or an impact of theparticular maintenance task. In an embodiment, the data packet generator126 determines an impact on the particular machine's operation caused bythe particular maintenance task. If the impact is zero, then the effectdue to the particular maintenance task is also zero. If the impact isthat the particular machine needs to be shut down, then the data packetgenerator 126 determines a particular value of the products to beproduced and/or generated during the particular time window according tothe particular production schedule. The particular value of the productsis the lost value caused by the particular maintenance task on theparticular machine. If the impact is that only a particular percentageof the products can be produced, then the data packet generator 126determines a number of products to be produced and/or generated duringthe particular time window according to the particular productionschedule. The data packet generator 126 applies the particularpercentage to the number of products to be generated without theparticular maintenance task to determine a number of products to begenerated with the particular maintenance task. The data packetgenerator 126 determines a difference between the number of products tobe generated without the particular maintenance task and the number ofproducts to be generated with the particular maintenance task. The datapacket generator 126 determines a lost value corresponding to theproducts that can no longer be produced as a result of performing theparticular maintenance task. The lost value is the impact caused by theparticular maintenance task on the particular machine.

In an embodiment, the data packet generator 126 determines a lost valuedue to the particular maintenance task during each of the remaining timewindows according to the particular production schedule. The data packetgenerator 126 normalizes and/or ranks the particular lost value duringthe particular time window based on the lost values during each of theremaining time windows. The normalized result and/or ranking is theeffect on the particular cost value due to the particular productionschedule. In another embodiment, the data packet generator 126determines lost values for the particular machine during each of theremaining time windows according to the particular production schedule.The data packet generator 126 also determines lost values, caused by theparticular maintenance task, for each of the remaining machines duringeach time window according to respective production schedules of themachines. The data packet generator 126 normalizes and/or ranks theparticular lost value for the particular machine during the particulartime window based on the lost values for each machine during each timewindow. The normalized result and/or ranking is the effect on theparticular cost value due to the particular production schedule. Inanother embodiment, the data packet generator 126 simply takes theparticular lost value for the particular machine during the particulartime window caused by the particular maintenance task as the effect onthe particular cost value due to the particular production schedule.Hence, a greater lost value for a machine results in a greater effect ona cost value.

The data packet generator 126 determines aggregates effects due tovarious attributes described above in order to determine a cost value.Various methods may be used for determining a cost value, examples ofwhich are described below.

In an embodiment, the data packet generator 126 determines a sum of theeffects as the cost value. In another embodiment, the data packetgenerator 126 determines a product of the effects as the cost value. Inanother embodiment, the data packet generator 126 computes a weightedsum of the effects. The data packet generator 126 applies a first weightto the effect due to a failure probability, a second weight to theeffect due to a current-assigned time window, and a third weight to theeffect due to a lost value. The data packet generator 126 determines asum of the weighted effects. The sum is the cost value.

In an embodiment, the data packet generator 126 applies amulti-attribute utility function to the machine attributes and/or taskattributes. The multi-attribute utility function represents cost valuesgiven a production schedule and a failure probability. A machine maygenerate a value of goods according to the production schedule if themachine does not fail, but may generate zero value if the machine doesfail. Based on at least the production schedule and failure probability,the multi-attribute utility function outputs a cost value for each timewindow for each maintenance task.

Cost values for a particular maintenance task during each time windowmay be the same or different. Cost values for each maintenance taskduring a particular time window may be the same or different. As anexample, a set of maintenance tasks include: Task A, Task B, and Task C.Time windows available for performing Task A are: Monday and Wednesday.Time windows available for performing Task B are: Monday, Wednesday, andFriday. Time windows available for performing Task C are: Tuesday andThursday. Based on a set of machine attributes and task attributes, adata packet generator may determine that a set of cost values for TaskA, Task B, and Task C during the time windows Monday through Friday areas follows:

TABLE 1 Monday Tuesday Wednesday Thursday Friday Task A 98 N/A 30 N/AN/A Task B 45 N/A 65 N/A 70 Task C N/A 53 N/A 88 N/A

One or more embodiments include generating one or more data packetsincluding information about the maintenance tasks and candidate timewindows (Operation 214). The data packet generator 126 generates one ormore data packets based on the information obtained at Operations202-212. The data packet indicates the maintenance tasks to beperformed, and the candidate time windows for performing the maintenancetasks. The data packet indicates respective maximum task counts for thecandidate time windows. The data packet indicates cost values per timewindow per maintenance task. The data packet may be stored as a softwaredata structure. The data packet may include one or more arrays, vectors,linked lists, tables, software variables, constants, and/or dataobjects. The data packet may include a set of instructions executable byone or more devices including a hardware processor.

B. Determining a Constraint Programming Data Model

FIGS. 3A-B illustrates an example set of operations for generating aconstraint programming data model, in accordance with one or moreembodiments.

One or more embodiments include specifying a set of task elements, eachtask element representing a maintenance task (Operation 302). A datamodel generator 114 specifies a set of task elements. The set of taskelements may be represented by a vector, an array, and/or any other datastructure. Each task element represents one of the set of maintenancetasks determined at Operation 204 of FIG. 2.

One or more embodiments include specifying domains of the task elements,each domain representing candidate time windows for performing amaintenance task (Operation 304). The data model generator 114 specifiesdomains of the task elements. Each domain may be represented by avector, an array, and/or any other data structure. A domain for aparticular task element represents the set of candidate time windows forperforming a maintenance task represented by the particular taskelement. Optionally, each of the domains of the task elements may alsoinclude an overflow time window.

As an example, a set of maintenance tasks may include Task A and Task B.Candidate time windows for performing Task A may include Monday andTuesday. Candidate time windows for performing Task B may includeWednesday and Thursday.

A data model generator may specify a set of task elements, representingthe maintenance tasks, expressed as vector M[i]. M[0] may represent TaskA. M[1] may represent Task B. The domains of the task elements may be asfollows:

M[0]: {1, 2, 7}

M[1]: {3, 4, 7}

wherein the values 0-7 within the domains represent (a) candidate timewindows, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday,and (b) an overflow time window, respectively. The overflow time window(represented by “7”) is included each domain of the task elements.

One or more embodiments include specifying a set of time elements, eachtime element representing a candidate time window (Operation 306). Thedata model generator 114 specifies a set of time elements. The set oftime elements may be represented by a vector, an array, and/or any otherdata structure. Each time element represents one of the set of timewindows determined at Operation 208 of FIG. 2. Optionally, an additionaltime element represents the overflow time window.

One or more embodiments include specifying domains of the time elements,each domain representing task counts permitted during a time window(Operation 308). The data model generator 114 specifies domains of thetime elements. Each domain may be represented by a vector, an array,and/or any other data structure. A domain for a particular time elementrepresents the task counts permitted during a time window represented bythe particular time element. A domain for the overflow time window mayindicate that a maximum task count for the overflow time window is equalto the number of maintenance tasks.

As an example, a set of time windows may include 9 am-11 am, 12 pm-2 pm,and 3 pm-5 pm. A maximum number of maintenance tasks that may beperformed during 9 am-11 am may be 3. Hence, tasks counts permittedduring 9 am-11 am are: 0, 1, 2, 3. A maximum number of maintenance tasksthat may be performed during 12 pm-2 pm may be 2. Hence, tasks countspermitted during 12 pm-2 pm are: 0, 1, 2. A maximum number ofmaintenance tasks that may be performed during 3 pm-5 pm may be 4.Hence, tasks counts permitted during 3 pm-5 pm are: 0, 1, 2, 3, 4. Anumber of maintenance tasks to be performed may be six. Hence, taskcounts permitted for the overflow time window are: 0, 1, 2, 3, 4, 5, 6.

A data model generator may specify a set of time elements, representingthe time windows, expressed as vector T[i]. T[0] may represent 9 am-11am. T[1] may represent 12 pm-2 pm. T[2] may represent 3 pm-5 pm. T[3]may represent an overflow time window. The domains of the time elementsmay be as follows:

T[0]: {0, 1, 2, 3}

T[1]: {0, 1, 2}

T[2]: {0, 1, 2, 3, 4}

T[3]: {0, 1, 2, 3, 4, 5, 6}

One or more embodiments include specifying a set of cost elementscorresponding to the set of task elements (Operation 310). The datamodel generator 114 specifies a set of cost elements. The set of costelements may be represented by a vector, an array, and/or any other datastructure. Each cost element corresponds to the set of task elementsdetermined at Operation 302.

One or more embodiments include specifying domains of the set of costelements, each domain indicating possible cost values to be assigned tothe corresponding cost element (Operation 312). The data model generator114 specifies domains of the cost elements. Each domain may berepresented by a vector, an array, and/or any other data structure. Adomain for a particular cost element represents possible cost values tobe assigned to the corresponding cost element. The possible cost valuesinclude at least a subset of the set of cost values determined atOperation 212 of FIG. 2.

Optionally, if an overflow time window is used, the domain of each costelement may further include an overflow cost value for the overflow timewindow. The overflow cost value is any value greater than the largestpossible cost value.

As an example, a set of maintenance tasks may include Task A and Task B.Candidate time windows for performing Task A may include Monday andTuesday. Candidate time windows for performing Task B may includeWednesday and Thursday.

For Task A, a cost value for Monday may be 100; a cost value for Tuesdaymay be 200. For Task B, a cost value for Wednesday may be 300; a costvalue for Thursday may be 350.

A data model generator may specify a set of task elements, representingthe maintenance tasks, expressed as vector M[i], as follows:

M[0]: {1, 2, 7}

M[1]: {3, 4, 7}

wherein the values 0-7 within the domains represent (a) candidate timewindows, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday,and (b) an overflow time window, respectively.

The data model generator may further specify a set of cost elements,expressed as a vector C[i]. The cost elements correspond to the taskelements, such that C[i] corresponds to M[i]. Hence, C[0] corresponds toM[0], and C[1] corresponds to M[1].

The data model generator may further specify domains of the costelements. The domain of each cost element indicates possible cost valuesfor performing the corresponding maintenance task. Hence, the domain ofC[0] includes the possible cost values for performing TaskA, which are100 and 200. The domain of C[1] includes the possible cost values forperforming Task B, which are 300 and 350.

The domain of each cost element further includes an overflow cost value,which is greater than the largest possible cost value. Since thepossible cost values are 100, 200, 300, and 350, the overflow cost valuemay be any number greater than 350.

Hence, the cost elements may be expressed as follows:

C[0]: {100, 200, 1000}

C[1]: {300, 350, 1000}

wherein the value 1000 within the domains represent the overflow costvalue. The overflow cost value is included each domain of the costelements.

One or more embodiments include specifying a total cost elementrepresenting a total cost value (Operation 314). The data modelgenerator 114 specifies a total cost element. The total cost element maybe represented by a vector, an array, a variable, and/or any other datastructure.

One or more embodiments include specifying a domain of the total costelement indicating possible total cost values to be assigned to thetotal cost element (Operation 316). The data model generator 114specifies a domain of the total cost element. The domain may berepresented by a vector, an array, and/or any other data structure. Adomain for the total cost element represents possible total cost valuesto be assigned to the total cost element. The possible cost valuesinclude the possible sums determined from the possible cost values forthe set of cost elements.

As an example, a data model generator may specify a set of costelements:

C[0]: {100, 200, 1000}

C[1]: {300, 350, 1000}

Possible sums determined from the possible cost values include:

100+300=400

100+350=450

100+1000=1100

200+300=500

200+350=550

200+1000=1200

1000+300=1300

1000+350=1350

1000+1000=2000

The data model generator may specify a total cost element, expressed asa vector TC, as follows:

TC: {400, 450, 500, 550, 1100, 1200, 1300, 1350, 2000}

One or more embodiments include specifying a global cardinalityconstraint requiring each task element to be assigned a time window fromthe respective domain, such that each time element is associated with atask count from the respective domain (Operation 318). The data modelgenerator 114 specifies a global cardinality constraint (GCC) requiringeach task element to be assigned a time window from the respectivedomain, such that each time element is associated with a task count fromthe respective domain. The constraint requires that a particular taskelement be assigned a time window from a domain of the particular taskelement. The constraint requires that a particular time element isassociated with a task count from a domain of the particular timeelement.

In an embodiment, the data model generator 114 specifies a GCC with theinputs: (a) the set of task elements, (b) values that may be assigned toany of the set of task elements, and (c) the set of time elements. Basedon the GCC, each task elements is assigned a value from a domain of thetask element. Further, the set of time elements serve as countingelements that count a number of times each time window is assigned. Eachtime element may only assume a value from a domain of the time element.In other embodiments, other types of constraints may be used forexpressing a constraint requiring each task element to be assigned atime window from the respective domain, such that each time element isassociated with a task count from the respective domain.

One or more embodiments include specifying an element constraintrequiring each cost element to be assigned a cost value associated witha time window assigned (or to be assigned) to a corresponding taskelement (Operation 320). The data model generator 114 specifies anelement constraint requiring each cost element to be assigned a costvalue associated with a time window assigned (or to be assigned) to acorresponding task element.

In an embodiment, the data model generator 114 specifies an elementconstraint with the inputs: (a) a particular task element, and (b) aparticular sequence of values indicating a cost value for performing themaintenance task represented by the particular task element during eachtime window. The data model generator 114 specifies that the elementconstraints outputs to a particular cost element corresponding to theparticular task element. Based on the element constraint, the timewindow assigned to the particular task element maps to a particularvalue within the particular sequence of values. The particular valuemust be within the domain of the particular cost element. In otherembodiments, other types of constraints may be used for expressing aconstraint requiring each cost element to be assigned a cost valueassociated with a time window assigned (or to be assigned) to acorresponding task element.

One or more embodiments include specifying a sum constraint requiringthe total cost element to be a sum of the cost values assigned (or to beassigned) to each cost element (Operation 322). The data model generator114 specifies a sum constraint requiring the total cost element to be asum of the cost values assigned (or to be assigned) to each costelement.

In an embodiment, the data model generator 114 specifies a sumconstraint with the inputs being the set of cost elements. The datamodel generator 114 specifies that the sum constraint outputs to thetotal cost element. Based on the sum constraint, the sum of the valuesassigned (or to be assigned) to each cost element must be within thedomain of the total cost element. In other embodiments, other types ofconstraints may be used for expressing a constraint requiring the totalcost element to be a sum of the cost values assigned (or to be assigned)to each cost element.

One or more embodiments include generating a data model including thetask elements, the time elements, the cost elements, the total costelement, the global cardinality constraint, the element constraint, andthe sum constraint (Operation 324). The data model generator 114generates a data model including the task elements, the time elements,the cost elements, the total cost element, the global cardinalityconstraint, the element constraint, and the sum constraint. The datamodel may be stored as a software data structure. The data model mayinclude one or more arrays, vectors, linked lists, tables, softwarevariables, constants, and/or data objects. The data model may include aset of instructions executable by one or more devices including ahardware processor.

C. Determining a Constraint Programming Search Directive

As described above, a preference for assigning a particular maintenancetask to a preferred time window may be indicated in a data model byincorporating the preference with cost factors for the particularmaintenance task for various time windows. The preferred time window maybe but is not necessarily a currently-assigned time window for theparticular maintenance task.

Additionally or alternatively, a preference for assigning a particularmaintenance task to a preferred time window may be indicated in a datamodel using a CP construct, such as a soft constraint. A CP constructmay be used to limit search to a time window nearest to the preferredtime window. A CP construct may cause time windows to be sorted based ondistances between each time window and the preferred time window. Hence,a CP construct may guide the CP solver 132 to perform a preference-basedsearch.

Additionally or alternatively, a preference for assigning a particularmaintenance task to a preferred time window may be indicated in a searchdirective, as further described below. FIG. 4 illustrates an example setof operations for generating a constraint programming search directive,in accordance with one or more embodiments.

One or more embodiments include specifying one or more instructions foridentifying a target task element (Operation 402). A search directivegenerator 116 determines, specifies, and/or obtains instructions and/oroperations for traversing each of the set of task elements specified atOperation 302. The instructions include selecting a particular taskelement, representing a particular maintenance task, as an initial“target task element.” In subsequent iterations, traversing the set oftask elements, another task element may be selected as the “target taskelement.”

One or more embodiments include specifying one or more instructions foridentifying a candidate time window within the domain of the target taskelement that (a) is nearest to a preferred time window and (b) remainsavailable (Operation 404).

In an embodiment, the search directive generator 116 uses a differencevariable to track a distance from the preferred time window. The searchdirective generator 116 specifies instructions and/or operations thatinitially set the difference variable to a difference value of zero. Thedifference value is incremented with each iteration for traversing theset of task elements.

The search directive generator 116 specifies instructions and/oroperations for identifying a candidate earlier time window and acandidate later time window. The candidate earlier time window is enumber of time windows before the preferred time window, wherein eequals the difference value. The candidate later time window is l numberof time windows after the current time window, wherein l equals thedifference value. Initially, the difference value may be set to zero. Inthis case, both the candidate earlier time window and the candidatelater time window are equal to the current time window.

As an example, a set of candidate time windows may include Monday,Tuesday, Wednesday, Thursday, and Friday. A preferred time window for amaintenance task may be Wednesday. Initially, a difference value may be0. Then a candidate earlier time window is 0 time windows before thecurrent time window. Hence, the candidate earlier time window isWednesday. Similarly, a candidate later time window is 0 time windowsafter the current time window. Hence, the candidate later time window isalso Wednesday. In subsequent iterations, the difference value may beincremented.

The search directive generator 116 specifies instructions and/oroperations for determining whether both the candidate earlier timewindow and the candidate later time window are unavailable for beingassigned to the target task element. Whether a time window is availablefor assignment depends on (a) a domain of the target task element,and/or (b) current task counts for the set of time elements.

In an embodiment, a domain of a task element is updated based on taskcounts for the set of time elements. When a maximum task count for aparticular time element is reached, the time window represented by theparticular time element is removed from domains of the task elements.Hence, a time window is available for assignment if the time windowcurrently remains in the domain of the target task element.

In another embodiment, a domain of a task element is not updated basedon task counts for the set of time elements. Hence, a time window isavailable for assignment if (a) the time window is in the domain of thetarget task element and (b) a maximum task count for the time elementrepresenting the time window has not yet been reached.

The search directive generator 116 specifies instructions and/oroperations to be performed responsive to determining that both thecandidate earlier time window and the candidate later time window areunavailable for being assigned to the target task element. Theoperations indicate incrementing the difference value, identifying a newcandidate earlier time window and new candidate later time window, anditerating the process of determining whether both the candidate earliertime window and the candidate later time window are unavailable.

As an example, a search directive generator may specify instructionsthat use a difference variable for keeping track of the differencebetween the candidate time window being attempted and a preferred timewindow. The instructions may include initializing the differencevariable to zero; determining whether at least one of a candidateearlier time window and a candidate later time window, both of whichhave a distance from the preferred time window equal to the currentvalue of the difference variable, is available; and a loop thatincrements the difference variable if neither the candidate earlier timewindow nor the candidate later time window is available.

One or more embodiments include specifying one or more instructions forprioritizing assignment of a particular time window, of the candidateearlier time window and the candidate later time window, that isavailable for assignment to the target task element (Operation 406). Thesearch directive generator 116 determines, specifies, and/or obtainsinstructions and/or operations for prioritizing assignment of aparticular time window, of the candidate earlier time window and thecandidate later time window, available for assignment to the target taskelement, if at least one of the candidate earlier time window and thecandidate later time window is available. If the candidate earlier timewindow is available for performing the target maintenance task, and thecandidate later time window is not available for performing the targetmaintenance task, then the candidate earlier time window is prioritized.If the candidate earlier time window is not available for performing thetarget maintenance task, and the candidate later time window isavailable for performing the target maintenance task, then the candidatelater time window is prioritized. If both the candidate earlier timewindow and the candidate later time window are available for performingthe target maintenance task, then any of the candidate earlier timewindow or the candidate later time window is prioritized. Whether toprioritize the candidate earlier time window or the candidate later timewindow may be determined randomly. Additionally or alternatively,whether to prioritize the candidate earlier time window or the candidatelater time window may be determined based on a rule and/or a function.As an example, a user may desire to prioritize the candidate earliertime window whenever possible. Hence, if both the candidate earlier timewindow and the candidate later time window are available for performingthe target maintenance task, then the candidate earlier time window isprioritized.

Prioritizing assignment of the particular time window to the targetmaintenance task may include attempting to assign the particular timewindow to the target maintenance task before attempting other timewindows. The particular time window is hence preliminarily assigned tothe target maintenance task. As further described below with referenceto FIG. 5, a CP solver 132 may backtrack on preliminary assignments asnecessary. Alternatively, the CP solver 132 may finalize preliminaryassignments upon finding a CP solution that satisfies all constraints.

As an example, a preferred time window for a target maintenance task maybe 12 pm-1 pm. A candidate earlier time window may be 11 am-12 pm. Acandidate later time window may be 1 pm-2 pm. The candidate earlier timewindow may be available for performing the target maintenance task. Thecandidate later time window is not available for performing the targetmaintenance task. A search directive generator may determineinstructions which prioritize assignment of the candidate earlier timewindow, over other time windows that have not yet been attempted for thetarget maintenance task, to the target task element representing thetarget maintenance task.

One or more embodiments include generating a CP search directiveincluding the above instructions (Operation 408). The search directivegenerator 116 generates a CP search directive including the aboveinstructions. The above instructions in the CP search directive areiterated for each of the task elements; hence a different task elementis identified as the “target task element” for each iteration. The CPsearch directive may be stored as a software data structure. The CPsearch directive may include one or more arrays, vectors, linked lists,tables, software variables, constants, and/or data objects. The CPsearch directive may include a set of instructions executable by one ormore devices including a hardware processor.

D. Applying a Constraint Programming Data Model and Search Directive toa Constraint Programming Solver

FIG. 5 illustrates an example set of operations applying a constraintprogramming data model and search directive to a constraint programmingsolver, in accordance with one or more embodiments. The CP data modeland search directive are iteratively applied to determine a CP solutionassociated with a total cost element assigned with a lowest total costvalue (as compared with other possible CP solutions).

One or more embodiments include accepting, by a CP solver, a CP datamodel and a CP search directive as input parameters (Operation 502). ACP solver 132 accepts a CP data model and a CP search directive as inputparameters. Examples of operations for generating the CP data model aredescribed above with reference to FIGS. 3A-B. Examples of operations forgenerating the CP search directive are described above with reference toFIG. 4.

One or more embodiments include determining whether the CP solver canreturn a CP solution based on the CP data model and the CP searchdirective (Operation 504). The CP solver 132 applies one or moreconstraint programming techniques to the CP data model, guided by the CPsearch directive. The CP solver 132 determines a CP solution based onthe CP data model and the CP search directive, or determines that no CPsolution that satisfies all hard constraints of the CP data modelexists.

As an example, a CP solver may traverse each of a set of task elementsspecified by a CP data model to determine a CP solution. The CP solvermay begin with a particular task element. A value from the domain of theparticular task element is preliminarily assigned to the particular taskelement. If this preliminary assignment violates a constraint specifiedby the CP data model, then another value from the domain of theparticular task element is preliminarily assigned to the particular taskelement. If all values from the domain of the particular task elementare attempted and do not satisfy the constraint, then re-assignment ofone or more task elements previously traversed is performed. Inparticular, a value from the domain of a previously-traversed taskelement was preliminarily assigned to the previously-traversed taskelement. Based on the need for re-assignment, another value from thedomain of the previously-traversed task element is now preliminarilyassigned to the previously-traversed task element. Then, assignment ofthe particular task element is re-attempted.

Additionally, the CP solver may be guided by a CP search directive. TheCP search directive may determine a sequence in which time windows areattempted for assignment to one or more task elements. If assignment ofTime Window A to a particular maintenance task is attempted before TimeWindow B, and a valid CP solution is found, then the assignment of TimeWindow A is finalized, regardless of whether assignment of Time Window Bwould have arrived at a valid CP solution. Hence, assignment of TimeWindow A is prioritized over Time Window B.

Hence, the CP solver may traverse each task element, until each taskelement is assigned a time window from the respective domain, withoutviolating the constraints. The CP solver may determine the preliminaryassignments as final assignments. The final assignments constitute a CPsolution.

Alternatively, the CP solver may traverse each task element, untilassignment of each time window to the task elements is attempted, andyet none of the assignments satisfy the constraints. Then, the CP solvermay determine that there is no valid CP solution for the CP data model.The CP solver may return a message indicating that no CP solutionexists.

In an embodiment, the CP solver 132 updates domains of data modelelements as the CP solver 132 traverses and assigns values to the datamodel elements. The CP solver 132 removes values from domains that areno longer possible, given the preliminary assignments made thus far. TheCP solver 132 removes values from the domains that would violate anyhard constraints in the data model.

As an example, a CP solver may update a domain of a task element basedon task counts for a set of time elements. When a maximum task count fora particular time element is reached, a particular time windowrepresented by the particular time element may be removed from alldomains of the task elements. Hence, as the CP solver traverses a nexttask element, assignment of the particular time window to the next taskelement is not possible.

In an embodiment, certain time window restrictions are used. The CPsolver 132 updates domains of data model elements, while traversingthrough the data model elements, based on the time window restrictions.

As an example, a time window restriction may require that certain taskelements be assigned with a same time window. A CP solver may make apreliminary assignment of a particular time window to one task element.Then the CP solver removes from the domain of the other task element alltime windows except the particular time window. Hence, the only possibletime window available for assignment is the particular time window. Bothtask elements would be assigned to the same time window.

As another example, a time window restriction may require that certaintask elements be assigned with different time windows. A CP solver maymake a preliminary assignment of a particular time window to one taskelement. Then the CP solver removes the particular time window from thedomain of the other task element. Hence, the particular time window isnot available for being assigned to the other task element. The two taskelements would be assigned different time windows.

As another example, a time window restriction may require that certaintask elements be assigned with a particular sequence of time windows-atime window assigned to T[i] must be before a time window assigned toT[j]. A CP solver may make a preliminary assignment of a particular timewindow to T[i]. Then the CP solver removes, from the domain of T[j], (a)the particular time window, and (b) all time windows that are before theparticular time window. Hence, the only possible time windows forassigning to T[j] are after the particular time window. Alternatively, aCP solver may make a preliminary assignment of a particular time windowto T[j]. Then the CP solver removes, from the domain of T[i], (a) theparticular time window, and

-   -   (b) all time windows that are after the particular time window.        Hence, the only possible time windows for assigning to T[i] are        before the particular time window.

If no CP solution is returned, then one or more embodiments includeusing the last-determined CP solution to return a proposed maintenanceschedule (Operation 514). Since no CP solution is returned in thecurrent iteration, the CP solver 132 retrieves the CP solution returnedin the last iteration. The CP solver 132 identifies the CP solution fromthe last iteration as the last-determined CP solution. The CP solver 132also identifies the CP solution from the last iteration as the CPsolution associated with the lowest total cost value (compared to otherCP solutions based on the data model generated at Operation 324).

Based on the last-determined CP solution, the CP solver 132 determineswhether any task elements are assigned with the overflow time window.Maintenance tasks represented by task elements assigned with theoverflow time window are not included in the proposed maintenanceschedule. For the remaining task elements, the CP solver 132 determinesthe time window assigned to each task element. Based on assignment of atime window to a task element, the CP solver 132 returns a proposedmaintenance schedule indicating that the maintenance task represented bythe task element is scheduled for performance during the assigned timewindow.

If a CP solution is returned, then one or more embodiments includedetermining whether an interrupt to the iterative process has beenreceived (Operation 506). As illustrated, Operations 502-512 form aniterative process for finding a CP solution associated with a lowesttotal cost value. A user and/or an application may interrupt theiterative process. As an example, a user may indicate via a userinterface that the user desires a best CP solution determined thus far,without waiting for the iterative process to complete.

If an interrupt is received, then one or more embodiments include usingthe last-determined CP solution to return a proposed maintenanceschedule (Operation 514). Since a CP solution is returned in the currentiteration, the CP solver 132 identifies the CP solution from the currentiteration as the last-determined CP solution. Examples of operations fordetermining a proposed maintenance schedule based on a CP solution aredescribed above with reference to Operation 514.

The last-determined CP solution is not necessarily the CP solutionassociated with the lowest total cost value. A request to resume theiterative process for determining the CP solution associated with thelowest total cost value may be received. In response to the resumptionrequest, the iterative process may continue at Operation 508.

If an interrupt is not received, then one or more embodiments includeidentifying the total cost value associated with the CP solution as a“current-minimum total cost value” (Operation 508). The CP solver 132identifies the total cost value assigned to the total cost elementassociated with the CP solution obtained at Operation 504. The totalcost value is identified as a “current-minimum total cost value.”

One or more embodiments include removing, from the domain of the totalcost element, any values greater than or equal to the current-minimumtotal cost value (Operation 510). The CP solver 132 uses thecurrent-minimum total cost value as an upper bound on the possible totalcost values to be assigned to the total cost element during a nextiteration. The CP solver 132 removes, from the domain of the total costelement, any values greater than or equal to the current-minimum totalcost value.

As an example, during a current iteration, the CP solver may return acurrent CP solution. The current CP solution may indicate that the totalcost element is assigned with a total cost value of 450. The CP solvermay determine 450 as the current-minimum total cost value. The CP solvermay determine that a current domain of the total cost element is 1100,200, 300, 450, 20001. The CP solver may remove, from the domain of thetotal cost element, any total cost values greater than or equal to 450.Hence, the CP solver may modify the domain of the total cost element tobecome {100, 200, 300}.

One or more embodiments include modifying the CP data model (Operation512). The CP solver 132 modifies the CP data model to include the totalcost element with the reduced domain. Based on Operation 510, the domainof the total cost element includes only total cost values that are belowthe current-minimum total cost value.

The CP solver 132 iterates Operations 502-512 with respect to themodified CP data model. At Operation 502, the CP solver 132 accepts theCP data model that has been modified as an input parameter. AtOperations 504-508, assuming that the CP solver 132 determines a new CPsolution based on the modified CP data model, the CP solver 132 updatesthe current-minimum total cost value. The CP solver 132 identifies atotal cost value assigned to the total cost element associated with thenew CP solution as the current-minimum total cost value. At Operation510, the CP solver 132 removes, from the domain of the total costelement, any values greater than or equal to the current-minimum totalcost value. At Operation 512, the CP solver 132 once again modifies theCP data model. The CP solver 132 continues the iterative process untilthe CP solver cannot find a CP solution at Operation 504, or aninterrupt is received at Operation 506. As described above withreference to Operation 514, when the CP 132 solver cannot find a CPsolution at Operation 504, or an interrupt is received at Operation 506,the CP solver 132 uses the last-determined CP solution to return aproposed maintenance schedule.

In one or more embodiments, additional and/or alternative operations forapplying a constraint programming data model and search directive to aconstraint programming solver may be performed, examples of which aredescribed below.

In an embodiment, before a first application of the CP data model to theCP solver 132 at Operation 502, the CP data model is modified. Aparticular value within the range of possible total cost values, in thedomain of the total cost element, is determined as an initial cutoffvalue. The initial cutoff value may be, for example, a median of thepossible total cost values. All values above the initial cutoff valueare removed from the domain of the total cost element. Hence, a firstrun of the CP solver 132 is required to generate a CP solution with atotal cost value below the initial cutoff value. By setting the initialcutoff value, the CP solver 132 may more efficiently arrive at a CPsolution with a lower total cost value, if a valid CP solution exists.

In an embodiment, the CP solver 132 iterates until all possible CPsolutions, for the data model generated at Operation 324, are found. TheCP solver 132 does not modify the domain of the total cost element basedon a prior iteration. Hence, the CP solver 132 may find a CP solutionwith a higher total cost value than a prior CP solution. Afterdetermining all possible CP solutions, the CP solver 132 compares thetotal cost values associated with each possible CP solution. The CPsolver 132 then identifies the CP solution with the lowest total costvalue.

In an embodiment, multiple CP solutions may be associated with a samelowest total cost value. The iterative process may be modified todetermine such CP solutions. At Operation 510, remove from the domain ofthe total cost element any values greater than the current-minimum totalcost value (but keep any value equal to the current-minimum total costvalue). At Operation 504, the CP solver attempts to find a CP solutionthat has not yet been found. If no further CP solutions can be found,then at Operation 514, the set of last-determined CP solutions with thesame total cost value are identified. One CP solution is selected fromthe set of last-determined CP solutions with the same total cost value.Any selection criteria may be used. As an example, a CP solver maydetermine a difference between (a) each proposed maintenance schedulegenerated from each of the set of last-determined CP solutions and (b)the current maintenance schedule. The proposed maintenance schedule withthe least difference is selected. As another example, a CP solver maydetermine a number of task elements assigned with an overflow timewindow in each of the set of last-determined CP solutions. A CP solutionwith the lowest number of tasks elements assigned with the overflow timewindow may be selected. The selected CP solution may be used to generatea proposed maintenance schedule.

FIG. 6 illustrates an example set of operations for presenting andexecuting a proposed maintenance schedule, in accordance with one ormore embodiments.

One or more embodiments include presenting, at a graphical userinterface (GUI), a proposed maintenance schedule (Operation 602). A GUI138 presents the proposed maintenance schedule determined at Operation514. The GUI 138 may overlay the proposed maintenance schedule over acurrent maintenance schedule. An example GUI overlaying a proposedmaintenance schedule on of a current maintenance schedule is describedbelow with reference to FIG. 7B.

One or more embodiments include determining whether user input acceptingthe proposed maintenance schedule has been received (Operation 604). TheGUI 138 presents an interface element configured to receive user inputaccepting, rejecting, and/or modifying the proposed maintenanceschedule. The GUI 138 determines whether any such user input has beenreceived via the interface element.

In one or more embodiments, user input accepting the proposedmaintenance schedule is not necessary. The proposed maintenance scheduleoutput from the CP solver is adopted without human intervention.

If user input has accepted the proposed maintenance schedule, one ormore embodiments include generating a set of instructions for performingthe set of maintenance tasks based on the proposed maintenance schedule(Operation 606). A set of instructions for performing the set ofmaintenance tasks based on the proposed maintenance schedule isgenerated.

In an embodiment, instructions for performing each maintenance task isobtained from a data repository. Additional instructions are determined,specified, and/or obtained for scheduling execution of the instructionsfor performing each maintenance task according to the proposedmaintenance schedule. The instructions are executable by at least onedevice including a hardware processor.

As an example, a first maintenance task may be to update Software X onServer X. The first maintenance task is implemented by a set ofinstructions that loads and installs Software X updates on Server X. Asecond maintenance task may be to update Software Y on Server Y. Thesecond maintenance task is implemented by a set of instructions thatloads and installs Software Y updates on Server Y.

A master server may obtain a proposed maintenance schedule from a CPsolver. The proposed maintenance schedule may indicate that the firstmaintenance task is scheduled for 9 am and the second maintenance taskis scheduled for 10 am. Based on the proposed maintenance schedule, themaster server may generate instructions for performing the firstmaintenance task and the second maintenance task according to theproposed maintenance schedule. The master server may generateinstructions to execute the instructions of the first maintenance task(loading and installing Software X updates on Server X) at 9 am. Themaster server may generate instructions to execute the instructions ofthe second maintenance task (loading and installing Software Y updateson Server Y) at 10 am.

One or more embodiments include performing the set of maintenance tasksaccording to the proposed maintenance schedule (Operation 608). One ormore maintenance resources accept the set of instructions generated atOperation 606. Based on the set of instructions, the maintenanceresources perform the set of maintenance tasks according to the proposedmaintenance schedule.

As an example, a proposed maintenance schedule may indicate that a firstmaintenance task is scheduled for 9 am and a second maintenance task isscheduled for 10 am. A master server may generate instructions forperforming the first maintenance task at 9 am and the second maintenancetask at 10 am. The master server may execute the instructions. Accordingto the instructions, the master server may perform the first maintenancetask at 9 am and the second maintenance task at 10 am.

As another example, a proposed maintenance schedule may indicate that afirst maintenance task is scheduled for 9 am and a second maintenancetask is scheduled for 10 am. A group of workers may view the proposedmaintenance schedule at a GUI. Based on the proposed maintenanceschedule, a worker may determine to perform the first maintenance taskat 9 am. Another worker may determine to perform the second maintenancetask at 10 am.

If user input has not accepted the proposed maintenance schedule, one ormore embodiments include generating a set of instructions for performingthe set of maintenance tasks based on the current maintenance schedule(Operation 610). Examples for generating a set of instructions forperforming maintenance tasks based on a schedule are described abovewith reference to Operation 606.

One or more embodiments include performing the set of maintenance tasksaccording to the current maintenance schedule (Operation 612). Examplesfor performing the set of maintenance tasks according to a schedule aredescribed above with reference to Operation 608.

4. Graphical User Interface for Presenting a Proposed MaintenanceSchedule

Example GUIs are described below for purposes of clarity. Componentsand/or operations described below should be understood as specificexamples which may not be applicable to certain embodiments.Accordingly, unless specifically indicated, components and/or operationsdescribed below should not be construed as limiting the scope of any ofthe claims.

FIG. 7A illustrates an example graphical user interface indicating acurrent maintenance schedule for performing a set of maintenance tasks,in accordance with one or more embodiments.

As illustrated, a GUI 700 presents a current maintenance schedule. TheGUI 700 presents a current maintenance schedule in table form. Timewindows 702 are represented by the columns of the table. Maintenancetasks 704 are presented by the rows of the table. As illustrated, timewindows 702 include Time A, Time B, Time C, Time D, . . . Time N.Maintenance tasks 704 include Task A, Task B, Task C, Task D, . . . TaskN.

The current maintenance schedule includes current assignments 706 oftime windows 702 to maintenance task 704, as indicated by solidrectangles. Based on the current maintenance schedule, Time A isassigned to Task A. Time B is assigned to Task B and Task N. Time D isassigned to Task C. Time N is assigned to Task D.

In other embodiments, other graphics may be used to represent thecurrent maintenance schedule and/or the current assignments.

FIG. 7B illustrates an example graphical user interface overlaying aproposed maintenance schedule, on top of a current maintenance schedule,for performing a set of maintenance tasks, in accordance with one ormore embodiments.

As illustrated, a GUI 710 presents a proposed maintenance scheduleoverlaid on a current maintenance schedule. The proposed maintenanceschedule is determined by a CP solver based on a CP data model and a CPsearch directive. Time windows 712 are represented by the columns of thetable. Maintenance tasks 714 are presented by the rows of the table. Asillustrated, time windows 712 include Time A, Time B, Time C, Time D, .. . Time N. Maintenance tasks 714 include Task A, Task B, Task C, TaskD, . . . Task N.

The current maintenance schedule includes current assignments 716 oftime windows 712 to maintenance task 714, as indicated by solidrectangles. Based on the current maintenance schedule, Time A isassigned to Task A. Time B is assigned to Task B and Task N. Time D isassigned to Task C. Time N is assigned to Task D.

The proposed maintenance schedule includes proposed assignments 718 oftime windows 712 to maintenance task 714, as indicated by dottedrectangles. If a dotted rectangle is not shown for a particularmaintenance task, then the current assignment and the proposedassignment are the same for the particular maintenance task. Based onthe proposed maintenance schedule, Time A is assigned to Task D. Time Bis assigned to Task B. Time C is assigned to Task N. Time D is assignedto TaskA and Task C.

The GUI 710 presents arrows representing modifications from the currentmaintenance schedule to the proposed maintenance schedule. Asillustrated, the time window for Task A is modified from Time A to TimeD. The time window for Task D is modified from Time N to Time A. Thetime window for Task N is modified from Time B to Time C.

In other embodiments, other graphics may be used to represent thecurrent maintenance schedule, the current assignments, the proposedmaintenance schedule, and/or the proposed assignments.

Based on GUI 710, a user may easily view the modifications from thecurrent maintenance schedule to the proposed maintenance schedule. Basedon the modifications, the user may make necessary changes to implementthe proposed maintenance schedule. As an example, the user may rearrangemaintenance resources according to the proposed maintenance schedule.

5. Hardware Overview

According to one embodiment, the techniques described herein areimplemented by one or more special-purpose computing devices. Thespecial-purpose computing devices may be hard-wired to perform thetechniques, or may include digital electronic devices such as one ormore application-specific integrated circuits (ASICs), fieldprogrammable gate arrays (FPGAs), or network processing units (NPUs)that are persistently programmed to perform the techniques, or mayinclude one or more general purpose hardware processors programmed toperform the techniques pursuant to program instructions in firmware,memory, other storage, or a combination. Such special-purpose computingdevices may also combine custom hard-wired logic, ASICs, FPGAs, or NPUswith custom programming to accomplish the techniques. Thespecial-purpose computing devices may be desktop computer systems,portable computer systems, handheld devices, networking devices or anyother device that incorporates hard-wired and/or program logic toimplement the techniques.

For example, FIG. 8 is a block diagram that illustrates a computersystem 800 upon which an embodiment of the invention may be implemented.Computer system 800 includes a bus 802 or other communication mechanismfor communicating information, and a hardware processor 804 coupled withbus 802 for processing information. Hardware processor 804 may be, forexample, a general purpose microprocessor.

Computer system 800 also includes a main memory 806, such as a randomaccess memory (RAM) or other dynamic storage device, coupled to bus 802for storing information and instructions to be executed by processor804. Main memory 806 also may be used for storing temporary variables orother intermediate information during execution of instructions to beexecuted by processor 804. Such instructions, when stored innon-transitory storage media accessible to processor 804, rendercomputer system 800 into a special-purpose machine that is customized toperform the operations specified in the instructions.

Computer system 800 further includes a read only memory (ROM) 808 orother static storage device coupled to bus 802 for storing staticinformation and instructions for processor 804. A storage device 810,such as a magnetic disk or optical disk, is provided and coupled to bus802 for storing information and instructions.

Computer system 800 may be coupled via bus 802 to a display 812, such asa cathode ray tube (CRT), for displaying information to a computer user.An input device 814, including alphanumeric and other keys, is coupledto bus 802 for communicating information and command selections toprocessor 804. Another type of user input device is cursor control 816,such as a mouse, a trackball, or cursor direction keys for communicatingdirection information and command selections to processor 804 and forcontrolling cursor movement on display 812. This input device typicallyhas two degrees of freedom in two axes, a first axis (e.g., x) and asecond axis (e.g., y), that allows the device to specify positions in aplane.

Computer system 800 may implement the techniques described herein usingcustomized hard-wired logic, one or more ASICs or FPGAs, firmware and/orprogram logic which in combination with the computer system causes orprograms computer system 800 to be a special-purpose machine. Accordingto one embodiment, the techniques herein are performed by computersystem 800 in response to processor 804 executing one or more sequencesof one or more instructions contained in main memory 806. Suchinstructions may be read into main memory 806 from another storagemedium, such as storage device 810. Execution of the sequences ofinstructions contained in main memory 806 causes processor 804 toperform the process steps described herein. In alternative embodiments,hard-wired circuitry may be used in place of or in combination withsoftware instructions.

The term “storage media” as used herein refers to any non-transitorymedia that store data and/or instructions that cause a machine tooperate in a specific fashion. Such storage media may comprisenon-volatile media and/or volatile media. Non-volatile media includes,for example, optical or magnetic disks, such as storage device 810.Volatile media includes dynamic memory, such as main memory 806. Commonforms of storage media include, for example, a floppy disk, a flexibledisk, hard disk, solid state drive, magnetic tape, or any other magneticdata storage medium, a CD-ROM, any other optical data storage medium,any physical medium with patterns of holes, a RAM, a PROM, and EPROM, aFLASH-EPROM, NVRAM, any other memory chip or cartridge,content-addressable memory (CAM), and ternary content-addressable memory(TCAM).

Storage media is distinct from but may be used in conjunction withtransmission media. Transmission media participates in transferringinformation between storage media. For example, transmission mediaincludes coaxial cables, copper wire and fiber optics, including thewires that comprise bus 802. Transmission media can also take the formof acoustic or light waves, such as those generated during radio-waveand infra-red data communications.

Various forms of media may be involved in carrying one or more sequencesof one or more instructions to processor 804 for execution. For example,the instructions may initially be carried on a magnetic disk or solidstate drive of a remote computer. The remote computer can load theinstructions into its dynamic memory and send the instructions over atelephone line using a modem. A modem local to computer system 800 canreceive the data on the telephone line and use an infra-red transmitterto convert the data to an infra-red signal. An infra-red detector canreceive the data carried in the infra-red signal and appropriatecircuitry can place the data on bus 802. Bus 802 carries the data tomain memory 806, from which processor 804 retrieves and executes theinstructions. The instructions received by main memory 806 mayoptionally be stored on storage device 810 either before or afterexecution by processor 804.

Computer system 800 also includes a communication interface 818 coupledto bus 802. Communication interface 818 provides a two-way datacommunication coupling to a network link 820 that is connected to alocal network 822. For example, communication interface 818 may be anintegrated services digital network (ISDN) card, cable modem, satellitemodem, or a modem to provide a data communication connection to acorresponding type of telephone line. As another example, communicationinterface 818 may be a local area network (LAN) card to provide a datacommunication connection to a compatible LAN. Wireless links may also beimplemented. In any such implementation, communication interface 818sends and receives electrical, electromagnetic or optical signals thatcarry digital data streams representing various types of information.

Network link 820 typically provides data communication through one ormore networks to other data devices. For example, network link 820 mayprovide a connection through local network 822 to a host computer 824 orto data equipment operated by an Internet Service Provider (ISP) 826.ISP 826 in turn provides data communication services through the worldwide packet data communication network now commonly referred to as the“Internet” 828. Local network 822 and Internet 828 both use electrical,electromagnetic or optical signals that carry digital data streams. Thesignals through the various networks and the signals on network link 820and through communication interface 818, which carry the digital data toand from computer system 800, are example forms of transmission media.

Computer system 800 can send messages and receive data, includingprogram code, through the network(s), network link 820 and communicationinterface 818. In the Internet example, a server 830 might transmit arequested code for an application program through Internet 828, ISP 826,local network 822 and communication interface 818.

The received code may be executed by processor 804 as it is received,and/or stored in storage device 810, or other non-volatile storage forlater execution.

6. Miscellaneous; Extensions

Embodiments are directed to a system with one or more devices thatinclude a hardware processor and that are configured to perform any ofthe operations described herein and/or recited in any of the claimsbelow.

In an embodiment, a non-transitory computer readable storage mediumcomprises instructions which, when executed by one or more hardwareprocessors, causes performance of any of the operations described hereinand/or recited in any of the claims.

Any combination of the features and functionalities described herein maybe used in accordance with one or more embodiments. In the foregoingspecification, embodiments have been described with reference tonumerous specific details that may vary from implementation toimplementation. The specification and drawings are, accordingly, to beregarded in an illustrative rather than a restrictive sense. The soleand exclusive indicator of the scope of the invention, and what isintended by the applicants to be the scope of the invention, is theliteral and equivalent scope of the set of claims that issue from thisapplication, in the specific form in which such claims issue, includingany subsequent correction.

What is claimed is:
 1. One or more non-transitory machine-readable mediastoring instructions which, when executed by one or more processors,cause: identifying a set of machine maintenance tasks to be performedfor a set of machines; identifying a set of time windows for performingthe set of machine maintenance tasks; identifying a set of cost valuesfor performing the set of machine maintenance tasks during the set oftime windows; generating a constraint programming data model,comprising: specifying a set of task elements representing the set ofmachine maintenance tasks; wherein a domain of a first task element, ofthe set of task elements, indicates possible time windows to be assignedto the first task element; and wherein the possible time windowsincludes at least a subset of the set of time windows; specifying a setof time elements representing at least the set of time windows; whereina domain of a first time element, of the set of time elements, indicatespossible task counts to be assigned to the first time element;specifying a set of cost elements corresponding to the set of taskelements; wherein a domain of a first cost element, of the set of costelements, indicates possible cost values to be assigned to the firstcost element; and wherein the possible cost values includes at least asubset of the set of cost values; specifying a total cost element;wherein a domain of the total cost element indicates possible total costvalues to be assigned to the total cost element; specifying a firstconstraint requiring at least that a first time window assigned to thefirst task element is one of the possible time windows, and a first taskcount assigned to the first time element is one of the possible taskcounts; specifying a second constraint requiring at least that the firstcost element be assigned with a first cost value that is (a) one of thepossible cost values and (b) is associated with performing a firstmachine maintenance task, represented by the first task element, duringthe first time window; specifying a third constraint requiring that thetotal cost element be assigned with a first total cost value that is (a)one of the possible total cost values and (b) is a sum of respectivecost values assigned, or to be assigned, to the set of cost elements;iteratively applying at least the constraint programming data model to aconstraint programming solver to determine a set of one or moresolutions satisfying at least the first constraint, the secondconstraint, and the third constraint; determining that, out of the setof solutions, a particular solution is associated with the total costelement that is assigned with a lowest total cost value; returning aparticular proposed machine maintenance schedule based on the particularsolution.
 2. The one or more media of claim 1, wherein iterativelyapplying at least the constraint programming data model to theconstraint programming solver to determine the set of solutionscomprises: applying at least the constraint programming data model tothe constraint programming solver to determine a first solution of theset of solutions; determining a first total cost value assigned to thetotal cost element associated with the first solution; modifying theconstraint programming data model, wherein modifying the constraintprogramming data model comprises: removing, from the domain of the totalcost element, any total cost values that are greater than or equal tothe first total cost value; applying at least the constraint programmingdata model that has been modified to the constraint programming solverto determine a second solution of the set of solutions; wherein a secondtotal cost value assigned to the total cost element associated with thesecond solution is less than the first total cost value.
 3. The one ormore media of claim 1, wherein: iteratively applying at least theconstraint programming data model to the constraint programming solverto determine the set of solutions comprises: applying at least theconstraint programming data model to the constraint programming solverto determine a first solution of the set of solutions; determining afirst total cost value assigned to the total cost element associatedwith the first solution; modifying the constraint programming datamodel, wherein modifying the constraint programming data modelcomprises: removing, from the domain of the total cost element, anytotal cost values that are greater than or equal to the first total costvalue; applying at least the constraint programming data model that hasbeen modified to the constraint programming solver; determining that nosolution is possible for the constraint programming model that has beenmodified; determining that, out of the set of solutions, the particularsolution is associated with the total cost element that is assigned withthe lowest total cost value comprises: responsive to (a) determiningthat no solution is possible for the constraint programming model thathas been modified and (b) determining that a last-determined solution,out of the set of solutions, is the first solution: identifying thefirst solution as the particular solution associated with the total costelement that is assigned with the lowest total cost value.
 4. The one ormore media of claim 1, wherein iteratively applying at least theconstraint programming data model to the constraint programming solverto determine the set of solutions comprises: identifying a particularvalue between a lowest total cost value, out of the possible total costvalues in the domain of the total cost element and a highest total costvalue, out of the possible total cost values in the domain of the totalcost element, as an initial cutoff value; modifying the constraintprogramming model, wherein modifying the constraint programming modelcomprises: removing, from the domain of the total cost element, anytotal cost values that are greater than or equal to the initial cutoffvalue; applying at least the constraint programming model that has beenmodified to the constraint programming solver to determine a firstsolution of the set of solutions; wherein a first total cost valueassigned to the total cost element associated with the first solution isless than the initial cutoff value.
 5. The one or more media of claim 1,wherein the set of solutions comprises all possible solutions for theconstraint programming data model.
 6. The one or more media of claim 1,wherein returning the particular proposed machine maintenance scheduleis responsive to receiving an interrupt to an iterative process forminimizing the total cost element.
 7. The one or more media of claim 6,further storing instructions which cause: subsequent to returning theparticular proposed machine maintenance schedule responsive to receivingthe interrupt: resuming iteratively applying at least the constraintprogramming data model to the constraint programming solver to determinea second solution; wherein a first total cost value assigned to thetotal cost element associated with the particular solution is greaterthan a second total cost value assigned to the total cost elementassociated with the second solution; returning a second proposed machinemaintenance schedule based on the second solution.
 8. The one or moremedia of claim 1, further storing instructions which cause: determininga subset of the cost values that is associated with performing the firstmachine maintenance task on a first machine, of the set of machines,during the possible time windows based at least on a first machineattribute associated with the first machine.
 9. The one or more media ofclaim 8, wherein the first machine attribute comprises one or more of: afailure probability of the first machine, and a production schedule ofthe first machine.
 10. The one or more media of claim 8, wherein aneffect on each of the subset of the set of cost values due to the firstmachine attribute is same.
 11. The one or more media of claim 1, furtherstoring instructions which cause: determining a subset of the set ofcost values that is associated with performing the first machinemaintenance task during the possible time windows based at least on afirst task attribute associated with the first machine maintenance task.12. The one or more media of claim 11, wherein the first task attributecomprises one or more of: a particular time window, of the set of timewindows, assigned to the first machine maintenance task according to acurrent machine maintenance schedule; and a time window restriction forthe first machine maintenance task.
 13. The one or more media of claim1, further storing instructions which cause: determining that aparticular time window, of the set of time windows, is assigned to thefirst machine maintenance task according to a current machinemaintenance schedule; determining a first cost value for performing thefirst machine maintenance task during the first time window; determininga second cost value for performing the first machine maintenance taskduring a second time window of the set of time windows; wherein a firstdifference between the particular time window and the first time windowis less than a second difference between the particular time window andthe second time window; wherein a first effect on the first cost valuedue to the first difference is less than a second effect on the secondcost value due to the second difference.
 14. The one or more media ofclaim 1, further storing instructions which cause: generating aconstraint programming search directive, comprising: specifying one ormore operations for prioritizing assignment of the first task elementwith a time window of the set of time windows that is (a) nearest to aparticular time window assigned to the first machine maintenance taskaccording to a current maintenance schedule and (b) remains available.15. The one or more media of claim 1, wherein generating the constraintprogramming data model further comprises: specifying a fourth constraintrequiring that the first time window assigned to the first task elementbe before a second time window assigned to a second task element of theset of task elements.
 16. The one or more media of claim 1, whereingenerating the constraint programming data model further comprises oneof: specifying a fourth constraint requiring that the first time windowassigned to the first task element and a second time window assigned toa second task element of the set of task elements be same; or specifyinga fifth constraint requiring that the first time window assigned to thefirst task element and a second time window assigned to a second taskelement of the set of task elements be different.
 17. The one or moremedia of claim 1, wherein generating the constraint programming datamodel further comprises: specifying a soft constraint indicating apreference for assigning a time window of the set of time windows to thefirst task element that is nearest to a particular time window.
 18. Theone or more media of claim 1, wherein: the possible time windows furtherincludes an overflow time window, wherein any of the set of taskelements assigned with the overflow time window is not performedaccording to the particular proposed maintenance schedule; the possiblecost values further includes an overflow cost value associated with theoverflow time window, wherein the overflow cost value is greater thaneach of the set of cost values.
 19. The one or more media of claim 1,further storing instructions which, when executed by the one or moreprocessors, cause: generating a set of instructions which, when executedby a second set of one or more hardware processors, cause performance ofat least a subset of the set of machine maintenance tasks according tothe particular proposed machine maintenance schedule.
 20. The one ormore media of claim 1, further storing instructions which, when executedby the one or more processors, cause: presenting, at a graphical userinterface (GUI), a current machine maintenance schedule for performingat least a subset of the set of machine maintenance tasks; overlayingthe particular proposed machine maintenance schedule on top of thecurrent machine maintenance schedule.
 21. The one or more media of claim1, wherein the particular proposed maintenance schedule indicates thatthe first machine maintenance task is scheduled for the first timewindow.
 22. The one or more media of claim 1, further storinginstructions which cause: determining a subset of the cost values thatis associated with performing the first machine maintenance task on afirst machine, of the set of machines, during the possible time windowsbased at least on (a) a first machine attribute associated with thefirst machine, and (b) a first task attribute associated with the firstmachine maintenance task; wherein the first machine attribute comprisesone or more of: (a) a failure probability of the first machine, and (b)a production schedule of the first machine; wherein the first taskattribute comprises one or more of: (a) a particular time window, of theset of time windows, assigned to the first machine maintenance taskaccording to a current machine maintenance schedule, and (b) a timewindow restriction for the first machine maintenance task; generating aset of instructions which, when executed by a second set of one or morehardware processors, cause performance of at least a subset of the setof machine maintenance tasks according to the particular proposedmachine maintenance schedule; presenting, at a graphical user interface(GUI), a current machine maintenance schedule for performing at least asubset of the set of machine maintenance tasks; overlaying theparticular proposed machine maintenance schedule on top of the currentmachine maintenance schedule; wherein: generating the constraintprogramming data model further comprises one or more of: specifying afourth constraint requiring that the first time window assigned to thefirst task element be before a second time window assigned to a secondtask element of the set of task elements; specifying a fifth constraintrequiring that the first time window assigned to the first task elementand a third time window assigned to a third task element of the set oftask elements be same; specifying a sixth constraint requiring that thefirst time window assigned to the first task element and a fourth timewindow assigned to a fourth task element of the set of task elements bedifferent; iteratively applying at least the constraint programming datamodel to the constraint programming solver to determine the set ofsolutions comprises: identifying a particular value between a lowesttotal cost value, out of the possible total cost values in the domain ofthe total cost element and a highest total cost value, out of thepossible total cost values in the domain of the total cost element, asan initial cutoff value; modifying the constraint programming model,wherein modifying the constraint programming model comprises: removing,from the domain of the total cost element, any total cost values thatare greater than or equal to the initial cutoff value; applying at leastthe constraint programming model, which has been modified to exclude anytotal cost values greater than or equal to the initial cutoff value fromthe domain of the total cost element, to the constraint programmingsolver to determine a first solution of the set of solutions; responsiveto receiving an interrupt: returning a temporary proposed machinemaintenance schedule based on the first solution; subsequent toreceiving the interrupt: determining a first total cost value assignedto the total cost element associated with the first solution, whereinthe first total cost value assigned to the total cost element associatedwith the first solution is less than the initial cutoff value; modifyingthe constraint programming data model, wherein modifying the constraintprogramming data model comprises: removing, from the domain of the totalcost element, any total cost values that are greater than or equal tothe first total cost value; applying at least the constraint programmingdata model, which has been modified to exclude any total cost valuesgreater than or equal to the first total cost value from the domain ofthe total cost element, to the constraint programming solver todetermine a second solution of the set of solutions; determining asecond total cost value assigned to the total cost element associatedwith the second solution, wherein the second total cost value is lessthan the first total cost value; modifying the constraint programmingdata model, wherein modifying the constraint programming data modelcomprises: removing, from the domain of the total cost element, anytotal cost values that are greater than or equal to the second totalcost value; applying at least the constraint programming data model,which has been modified to exclude any total cost values greater than orequal to the second total cost value from the domain of the total costelement, to the constraint programming solver; determining that nosolution is possible for the constraint programming model, which hasbeen modified to exclude any total cost values greater than or equal tothe second total cost value from the domain of the total cost element;determining that, out of the set of solutions, the particular solutionis associated with the total cost element that is assigned with thelowest total cost value comprises: responsive to (a) determining that nosolution is possible for the constraint programming model and (b)determining that a last-determined solution, out of the set ofsolutions, is the second solution: identifying the second solution asthe particular solution associated with the total cost element that isassigned with the lowest total cost value; the particular proposedmaintenance schedule indicates that the first machine maintenance taskis scheduled for the first time window.
 23. A system, comprising: one ormore devices, each including one or more hardware processors; the systembeing configured to perform operations comprising: identifying a set ofmachine maintenance tasks to be performed for a set of machines;identifying a set of time windows for performing the set of machinemaintenance tasks; identifying a set of cost values for performing theset of machine maintenance tasks during the set of time windows;generating a constraint programming data model, comprising: specifying aset of task elements representing the set of machine maintenance tasks;wherein a domain of a first task element, of the set of task elements,indicates possible time windows to be assigned to the first taskelement; and wherein the possible time windows includes at least asubset of the set of time windows; specifying a set of time elementsrepresenting at least the set of time windows; wherein a domain of afirst time element, of the set of time elements, indicates possible taskcounts to be assigned to the first time element; specifying a set ofcost elements corresponding to the set of task elements; wherein adomain of a first cost element, of the set of cost elements, indicatespossible cost values to be assigned to the first cost element; andwherein the possible cost values includes at least a subset of the setof cost values; specifying a total cost element; wherein a domain of thetotal cost element indicates possible total cost values to be assignedto the total cost element; specifying a first constraint requiring atleast that a first time window assigned to the first task element is oneof the possible time windows, and a first task count assigned to thefirst task element is one of the possible task counts; specifying asecond constraint requiring at least that the first cost element beassigned with a first cost value that is (a) one of the possible costvalues and (b) is associated with performing a first machine maintenancetask, represented by the first task element, during the first timewindow; specifying a third constraint requiring that the total costelement be assigned with a first total cost value that is (a) one of thepossible total cost values and (b) is a sum of respective cost valuesassigned, or to be assigned, to the set of cost elements; iterativelyapplying at least the constraint programming data model to a constraintprogramming solver to determine a set of one or more solutionssatisfying at least the first constraint, the second constraint, and thethird constraint; determining that, out of the set of solutions, aparticular solution is associated with the total cost element that isassigned with a lowest total cost value; returning a particular proposedmachine maintenance schedule based on the particular solution.
 24. Amethod, comprising: identifying a set of machine maintenance tasks to beperformed for a set of machines; identifying a set of time windows forperforming the set of machine maintenance tasks; identifying a set ofcost values for performing the set of machine maintenance tasks duringthe set of time windows; generating a constraint programming data model,comprising: specifying a set of task elements representing the set ofmachine maintenance tasks; wherein a domain of a first task element, ofthe set of task elements, indicates possible time windows to be assignedto the first task element; and wherein the possible time windowsincludes at least a subset of the set of time windows; specifying a setof time elements representing at least the set of time windows; whereina domain of a first time element, of the set of time elements, indicatespossible task counts to be assigned to the first time element;specifying a set of cost elements corresponding to the set of taskelements; wherein a domain of a first cost element, of the set of costelements, indicates possible cost values to be assigned to the firstcost element; and wherein the possible cost values includes at least asubset of the set of cost values; specifying a total cost element;wherein a domain of the total cost element indicates possible total costvalues to be assigned to the total cost element; specifying a firstconstraint requiring at least that a first time window assigned to thefirst task element is one of the possible time windows, and a first taskcount assigned to the first task element is one of the possible taskcounts; specifying a second constraint requiring at least that the firstcost element be assigned with a first cost value that is (a) one of thepossible cost values and (b) is associated with performing a firstmachine maintenance task, represented by the first task element, duringthe first time window; specifying a third constraint requiring that thetotal cost element be assigned with a first total cost value that is (a)one of the possible total cost values and (b) is a sum of respectivecost values assigned, or to be assigned, to the set of cost elements;iteratively applying at least the constraint programming data model to aconstraint programming solver to determine a set of one or moresolutions satisfying at least the first constraint, the secondconstraint, and the third constraint; determining that, out of the setof solutions, a particular solution is associated with the total costelement that is assigned with a lowest total cost value; returning aparticular proposed machine maintenance schedule based on the particularsolution; wherein the method is performed by one or more devices, eachincluding one or more hardware processors.